1.python文件的后缀名为 *.py

2.两种执行方式：

　　python解释器 py文件路径

　　python 进入解释器：

　　实时输入并获取到执行结果

3.在Linux下，文件名和文件内部与windows有所不同

　　文件名

　　./*.py

　　文件内部：

　　开头得加上 #/usr/bin/env python （声明一下是用哪个python解释器）

4.python2与python3的不同

　　python2默认的ASCII码编码，只能编码英文而不能对中文编码，当语句中出现中文时，

　　运行会报错，得在文件内部开头加上 # -*- coding：utf8 -*-，才能避免报错。

　　python3无需关注编码。

5.编码方式

　　ASCII-8位

　　eg: &--00100110

　　UNICODE-16位+

　　eg: &--0000000000100110 (浪费内存）

　　utf8-能用多少位表示就用多少位

　　eg: &--00100110

6.变量名只能由字母、数字、下划线组成。（不能用数字开头 ）

　python关键字也不能用于变量名。

7.条件语句

　　1).if 条件：　　（Tab键）代码块    　　else：　　（Tab键）代码块　　2). if 条件：　　（Tab键）if 条件：　　（Tab键）代码块　　else：　　（Tab键）代码块    　　else：　　（Tab键）代码块    　　3).if 条件：　　（Tab键）代码块　　elif 条件：　　（Tab键）代码块　　elif 条件：　　（Tab键）代码块　　...　　else：　　（Tab键）代码块　　4).当满足某条件不需要执行任何操作时　　eg: if 1===1 ：　　　　　pass      　　else：         　　  print("sb")

 

 

8.字符串（引号）：

　　name = "我是索得"　　name = '我是索得'　　name = """我是索得"""　　name = '''我是索得'''　　#加法：　　n1 = "chen"　　n2 = "jian"　　n3 = n1+n2　　n3 = "chenjian"　　#乘法：　　n1 = "chen"　　n2 = 5*n1　　n2 = "chenchenchenchenchen"

 

 

　　9.运算符

+ - * / **（指数计算，如10**3表示10的3次方）　　% //（取商）　　in not in （某个东西是否在另一东西里面）　　布尔值　　True　　false　　结果是值　　算术运算　　a=10*10　　a=a+1 a+=1　　结果是布尔值　　比较运算　　a=1>5　　逻辑运算　　a=1>6 or 1==1　　成员运算　　a='邹’ in '邹雨晴'

 

 

　　

10.基本数据类型

　　

数字

-int　　

将字符串转换为数字

a="123"print(type(a),a)    　　#输出a的类型、ab=int(a)    　　        #将字符串类型转换为数字类型print(type(b),b)　　    #输出b的类型、bnum="0011"v= int (num,base=16)    #将0011转换为16进制print v

 

*.bit_lenght

a=7r=a.bit_lenght()    　　#当前数字的二进制，至少用n位表示

 

 

字符串

 -str

m = "chen"n = "jian"print(m + n)　　 #输出为：chenjian

　

*.capitalize()　　 #将首字母大写,首字母除外小写

text = "CHEN"v1 = text.capitalize() print(v1)

 

 

 

*.casefold()　　 #转换成小写

text = "CHEN"v2 = text.casefold()

 

 

*.lower()　　 #转换成小写

v3 = text.lower() print(v3)

 

 

 

*.islower()　　 #判断是否全部是小写，小写返回值为真，否则为假

text = "CHEN"s1 = text.lower()

 

 

*.upper()　　 #转换成大写

text = 'lebron's2 = text.upper()

 

 

*.isupper()　　 #判断是否全部是大写，大写返回值为真，否则为假

text = 'Lerbron's3 = text.isupper()

 

 

*.center() 　　 #设置宽度并将内容居中，20指代总长度，"#"在空白位置填充，只能为一个字符，并且它可有可无

text = '湖人总冠军'v4 = text.center(20,"#") print(v4)

 

 

 

*.count()     #去字符串中寻找子序列出现的次数,后面的参数可以设置为起始位置和结束位置，这两数字参数可有可无

text1 = "chenchen"v5 = text1.count('e', 5, 6) print(v5)

 

 

 

*.endswith() 　　 #判断是否以指定字符结尾，若是则返回值为真

text1 = 'chen'v6 = text1.endswith('en')print(v6)

 

 

 

*.startswith() 　　 #判断是否以指定字符开头，若是则返回值为真

text1 = 'ensure'v7 = text1.startswith('en')print(v7)

 

 

 

*.find() 　　 #从开始往后找，找到第一个为止，返回其位置的索引值，数字参数表示从某个位置找到某个位置，数字参数可有可无

text1 = 'eneneenen'v8 = text1.find('en', 5, 8)print(v8)# v8=text1.index('en') 也是找字符，但未找到就会直接报错，不常用

 

*.format() 　　 #模式化，将一个字符串中的占位符替换为指定值

text2 = 'i am {name},{age}'v9 = text2.format(name='chen', age='22')print(v9)text3 = 'i am {0},{1}'v10 = text3.format('chen', '22')  # 模式化的另外一种方法，0和1表示在format中的位置

 

 

 

*.format_map()　　 #模式化的第三种方式

text2 = 'i am {name},{age}'v11 = text2.format_map({
    "name": 'chen', "age": 22}) print(v11)

 

*.isalnum()   #字符串中是否只包含数字和字母，返回值为布尔值

text4 = 'areyon23'v12 = text4.isalnum() print(v12)

 

 

*.expandtabs()   #制表

s1="usrname\tmail\tpasswd\nchen\t465116388@qq.com\t136136\nzou\t15874159563@qq.com\t123123"v = s1.expandtabs(20)    print(v, len(v))　　>>>

usrname       mail                  passwd

chen          465116388@qq.com      136136

zou           15874159563@qq.com    123123

 

 

 

 

*.isalpha 　　 #只包含字母或者汉字时，返回值为真，否则为假

test1 = "846"t = test1.isalpha() print(t)

 

 

 

*isidentifier() 　　 #只包含字母、数字、下划线及其组合，并且首位不是数字时，返回值为真，否则为假

test2 = "s1_56"s = test2.isidentifier() print(s)

 

 

*.isdigit *.isdecimal *.isnumeric

test3="1236"v1 = test3.isdigit()　　 　  #只包数字时，返回值为真，否则为假v2 = test3.isdecimal()　　 #只包数字时，返回值为真，否则为假 (最常用)v3 = test3.isnumeric() 　　 #只包数字（中文数字和圈数都行）时，返回值为真，否则为假print(v1, v2, v3)

 

 

 

*.isprintable　　 #包含不可显示的字符时，返回值为假，否则为真

test4 = "dasfj\tasfl"v4 = test4.isprintable() print(v4)

 

 

*.isspace() 　　 #只包含空格时，返回值为真，否则为假

v5 = test4.isspace() print(v5)

 

 

*.istitle() 　　 #为标题时(每个单词的首字母都是大写)返回为真,否则为假

test5 = "Hello my name is Chen"v6 = test5.istitle()print(v6)

 

 

 

*.title() 　　 #将字符串变成标题的形式

v7 = test5.title() print(v7)

 

 

 

*.join　　 #将字符串中的每一个元素按指定的分隔符连接 (重要)

test6 = "湖人总冠军"print(test6)t = '_'v8 = t.join(test6) print(v8)

 

*.ljust *.rjust *.zfill

test7 = "lebronjames"v9 = test7.ljust(20, '*')  #在字符串的后面用指定的字符填充为指定的长度v10 = test7.rjust(20, '*')  #在字符串的前面面用指定的字符填充为指定的长度v11 = test7.zfill(20)      #在字符串的前面用0填充为指定的长度print(v9)print(v10)print(v11)>>>lebronjames******************lebronjames000000000lebronjames

 

 

 

*.rstrip *lstrip *strip

test8 = "\t\tchenjian\t\t "v12 = test8.rstrip()   #去除右边空格、\t、\n，也可以在括号中指定字符来去除v13 = test8.lstrip()   #去除左边空格、\t、\n，也可以在括号中指定字符来去除v14 = test8.strip()    #两边空格都去除、\t、\n，也可以在括号中指定字符来去除print(v12)print(v13)print(v14>>>        chenjianchenjian         chenjian)

 

 

 

*.maketrans　　#指定字符进行替换

test9 = "火箭总冠军" m = str.maketrans("火箭", "湖人") v14 = test9.translate(m)print(v14) >>> 湖人总冠军

 

 

 

*.replace　　#指定字符进行替换，后面的数字表示替换的个数

　　n = test9.replace("火箭", "湖人", 1) 

　　print(n)

 

*.partition() *.rpartition

　　test10 = "湖人是总冠军，詹姆斯是FMVP"

　　v15 = test10.partition('是')　　 #从左至右指定某一字符对字符串进行分割

　　v16 = test10.rpartition('是') 　　 #从右至右指定某一字符对字符串进行分割

　　print(v15)

　　print(v16)

 

*.split()　　 #从左至右指定某一字符对字符串进行分割，分割后的字符串不包含该指定的字符,括号中的数字可以指定分割的次数，不加数字时，默认                       从头到尾进行分割

　　v17 = test10.split('是', 1)

　　print(v17)

 

*splitlines() 　　 #根据换行符进行分割，括号中的参数为true或者false，为true时保留换行符，为false时去掉换行符

　　test11 = "湖]人\n是他妈的\n总冠军\n"

　　v18 = test11.splitlines()

　　print(v18)

 

*.startswith() *.endswith()

　　test12 = "詹姆斯是联盟第一人"

　　v19 = test12.startswith('詹')　　 #判断字符串开头是否以指定字符开始，若是则返回值为true，否则为false

　　v20 = test12.endswith('人') 　　 #判断字符串结尾是否以指定字符结束，若是则返回值为true，否则为false

　　print(v19, v20)

 

*.swapcase() 　　 #大写转换成小写，小写转换成大写

　　test13 = "cHEN jIAN "

　　v21 = test13.swapcase()

　　print(v21)

 

 

#必须记住的功能： join split find upper lower replace

　　test14 = "chen"

　　v22 = test14[0] 　　 #获取字符串中的某一个字符，中括号里面的参数表示获取字符的位置

　　print(v22)

　　v23 = test14[0:2] 　　 #获取字符串中的某一个字符,并且指定获取字符的位置范围

　　print(v23)

　　test15 = "詹姆斯将会在总决赛中夺得FMVP"

　　count = 0

　　while count < len(test15):

　　　　v24 = test15[count]

　　　　print(v24)

　　　　count += 1

　　for lbj in test15: 　　 #for循环

　　　　print(lbj)

　　v25 = range(0, 100, 5) #生成大于等于0且小于100的

　　for item in v25:

　　print(item)

列表

  -list

　　li = [1,12,"chen",[1,89],true]

　　中括号括起来，逗号分割每个元素

　　列表中的元素可以是数字，字符串，列表，元祖，布尔值。。。

　　列表支持in操作

　　列表元素可以被修改、增加或删除

　　可以通过索引或者切片的方式取值

　　li = [1,12,"chen",[1,89],true]

　　li[1] = 0 　　#索引修改

　　print(li) 　　#输出为：li = [1,0,"chen",[1,89],true]

　　li[1:3] = [120,90] #切片修改

　　print(li) 　　#输出为：li = [1,120,90,[1,89],true]

可以增加

　　li = [1,12,"chen",[1,89],true]

　　li[1] = [12,6,98]

　　print(li)　　 #输出为：li = [1,12,6,9,"chen",[1,89],true]

可以删除：

　　li = [1,12,"chen",[1,89],true]

　　del li[1] 　　#索引删除

　　print(li)　　 #输出为：li = [1,"chen",[1,89],true]

　　del li[1:4] 　　 #切片删除

　　print(li) #输出为：li = [1,true]

对列表中列表的元素进行索引取值

　　li = [1,12,"chen",[1,89],true]

　　li[3][0] == '1'

　　li[2][0] == 'c'

字符串转列表

　　s = "asdlfjasld"

　　li = list(s) #字符串中每一个字符转换成列表中的元素

列表转字符串

1).列表中既有数字又有字符串时，需要自己写一个for循环

　　li = [1,12,"chen",[1,89],true]

　　s = ''

　　for i in li :

　　s += str(i)

　　print(s)　　 #输出为：112chen[1, 89]True

2).列表中只有字符串

　　li = ["chen", "jian", "zou"]

　　t = ''

　　v = t.join(li)

　　print(v)　　 #输出为:chenjianzou

数字不能迭代，所以不能转换成列表

 

*.append 　　 #在原列表最后加一个元素，当追加元素是列表时，将追加的元素看成一个整体加入

　　li = [11, 22, 33, 44]

　　li.append(5)

　　print(li) #输出为：[11, 22, 33, 44, 5]

 

*.clear　　 #清空

　　li = [11, 22, 33, 44]

　　li.clear()

　　print(li)　　 #输出为：[]

 

*copy 　　 #拷贝，浅拷贝

　　li = [11, 22, 33, 44]

　　v = li.copy()

　　print(v) 　　 #输出为[11, 22, 33, 44]

 

*.count 　　 #计算指定元素的个数

　　li = [11, 22, 33, 44]

　　v = li.count(22)

　　print(v) #输出为：1

 

*.extend　　 #扩张列表，参数是可迭代对象

　　li = [11, 22, 33, 44]

　　li.extend("chen")　　　　　　 输出为：#[11, 22, 33, 44, 'c', 'h', 'e', 'n']

　　li.extend([9898, "chen"]) 　　 输出为：#[11, 22, 33, 44, 9898, 'chen']

　　print(li)

 

*.index 　　 #根据指定值获取其索引位置（从左至右），参数1表示指定值，参数2表示起始位置，参数3表示结束位置（获取的是绝对位置）

　　li = [11, 22, 33, 44]

　　v = li.index(22, 0, 5)

　　print(v)　　 #输出为：1

 

*.insert　　 # 在指定索引位置插入元素

　　li = [11, 22, 33, 44]

　　li.insert(0,99)

　　print(li) #输出为：[99, 11, 22, 33, 44]

 

*.pop() 　　 #默认删除最后一个，加入索引可以删除指定值，并且获取删除值。可以理解为弹出列表的最后一个值

　　li = [11, 22, 33, 44]

　　v = li.pop()

　　print(li) 　　 #输出为：[11, 22, 33]

　　print(v) 　　 #输出为：44

 

*.remove 　　 #删除列表中的指定值，左边优先

　　li = [11, 22, 33, 44]

　　li.remove(33)

　　print(li)　　 #输出为：[11, 22, 44]

 

del *[]

　　li = [1, 12, "chen", [1, 89], True]

　　del li[1　　] # 索引删除

　　print(li) 　　 # 输出为：li = [1,"chen",[1,89],true]

　　del li[1:3]　　 # 切片删除

　　print(li) 　　 # 输出为：li = [1,true]

 

*.reverse 　　 #将当前列表进行反转

　　li = [11, 22, 33, 44]

　　li.reverse()

　　print(li)　　 #输出为：[44, 33, 22, 11]

 

*.sort() #列表的排序

　　li = [11, 33, 22, 44]

　　li.sort()　　 #从小到大排序

　　print(li)　　 #输出为: [11, 22, 33, 44]

　　li.sort　　(reverse=True) #从大到小排序

　　print(li)　　 #输出为：[44, 33, 22, 11]

元组 （不可改变的列表）

-tuple

　元祖中一级元素不可被修改、增加或者删除

　　元祖中的元素可以是数字，字符串，列表，元祖，布尔值。。。

　　元祖是有序的，可以通过索引或者切片的方式取值

　　可以被for循环，是可迭代对象

字符串、列表、元祖之间的相互转换

　　s = "chenjian"

　　li = ["chenjian", 23]

　　tu = (136, 136, "chen")

　　u = tuple(s)

　　v = tuple(li)

　　w = str(tu)

　　x = list(tu)

　　print(u)　　 # ('c', 'h', 'e', 'n', 'j', 'i', 'a', 'n')

　　print(v) 　　#('chenjian', 23)

　　print(w)　　#(136, 136, 'chen')

　　print(x)　　 # [136, 136, 'chen']

*.count() #指定元素的个数

　　tu = (136, 136, "chen")

　　v = tu.count(136)

　　print(v) 　　# 1

 

*.index() 　　#获取指定元素的索引位置（从左至右）

　　tu = (136, 158, 136, "chen")

　　v = tu.index(136, 1, 3)

　　print(v)　　 # 2

 

*.enumerate()

tu = ('alex', 'eric', 'rain')

for item, ele in enumerate(tu, 10): #enumerate()括号中不加数字时，默认从0开始。

print(item, ele)

输出为：10 alex

　　　　11 eric

　　　　12 rain

字典

 -dict

info = {"k1":1, "k2":True, "chen":"jian", (11, 22,):[1, 2], "k3":{"kk1":1, "kk2":2}}

　　字典的value可以是任何值

　　列表，字典不能作为字典的key

　　字典是无序的，不能通过切片的方式获得值，只能通过索引取值 info["k1"]为1

　　字典的value可以被删除和修改

　　字典可以进行for循环，默认是对key进行循环，也可以指定对value或者键值对进行循环

　　info = {

　　1:123

　　"k1":1,

　　"k2":True,

　　"chen":"jian",

　　(11, 22,):[1, 2],

　　"k3":{"kk1":1, "kk2":2}

　　}

　　for item in info: 　　 #对key进行循环，输出key的值

　　print(item)

　　for item in info.keys(): 　　 #对key进行循环，输出key的值

　　print(item)

　　for item in info.values(): 　　 #对value进行循环，输出value的值

　　print(item)

　　for item in info: 　　 #对key进行循环，输出键值对

　　print(item, info[item])

　　for k,v in info.items(): #对键值对进行循环，输出键值对

　　print(k,v)

　　dict.fromkeys 　　 # 根据序列创建字典，并指定统一的值

　　v = dict.fromkeys(["chen", "jian", 1], 136)

　　print(v) 　　 # {'chen': 136, 'jian': 136, 1: 136}

*.get()　　 # 根据key获取值，key不存在时，可以指定默认值（None）

　　info = {

　　"k1": 1,

　　"k2": True,

　　"chen": "jian", (11, 22,): [1, 2],

　　"k3": {"kk1": 1, "kk2": 2}

　　}

v = info.get('k1')

print(v)　　 # 1

 

*.pop 　　# 删除指定的key，并且可以获取被删除key所对应的value值

　　info = {

　　"k1": 1,

　　"k2": True,

　　"chen": "jian",

　　(11, 22,): [1, 2],

　　"k3": {"kk1": 1,

　　"kk2": 2}

　　}

v = info.pop("k1")

print(info, v)  　　# {'k2': True, 'chen': 'jian', (11, 22): [1, 2], 'k3': {'kk1': 1, 'kk2': 2}} 1

 

*.popitem     # 随机删除一个键值对，并且可以获取被删除的键值对

　　info = {

　　"k1": 1,

　　"k2": True,

　　"chen": "jian",

　　(11, 22,): [1, 2],

　　"k3": {"kk1": 1,

　　"kk2": 2}

　　}

　　k, v = info.popitem()

　　print(info, k, v) # {'k1': 1, 'k2': True, 'chen': 'jian', (11, 22): [1, 2]} k3 {'kk1': 1, 'kk2': 2}

 

*.setdefault 　　 # 设置值，如果设置key已经存在，则不设置，可获取当前值：若设置的key值不存在，则将设置的键值对加入字典，并获取当前可以                                对应的值

　　info = {

　　"k1": 1,

　　"k2": True,

　　"chen": "jian",

　　(11, 22,): [1, 2],

　　"k3": {"kk1": 1, "kk2": 2}

　　}

　　v = info.setdefault("k111", "136")

　　print(info, v)

 

*.update 　　 # 更新，指定键值对存在则覆盖，不存在则添加

　　info = {"k1": 1,

　　"k2": True,

　　"chen": "jian",

　　(11, 22,): [1, 2],

　　"k3": {"kk1": 1, "kk2": 2}

　　}

　　info.update({"k1": "111222", "k5": 123456}) 　　 # info.update(k1 = 123, k5 = 123456))

　　print(info)

10.集合

 set

l1 = [1, 2, 3] l2 = [2, 3, 4] print(set(l1)&set(l2)) print(set(l1)|set(l2))

输出：

 　　{2, 3}

　     {1, 2, 3, 4}

11.数据类型和变量总结

数字

字符串

列表

元组

字典

可变与不可变：

　　1.可变：数组、字典 （对其中的元素重新赋值后不会开辟新的内存空间）

　　2.不可变：字符串、数字、元组 （对变量名重新赋值后会开辟新的内存空间）

　　

访问顺序：

　　1.直接访问（通过变量名）

　　2.顺序访问（索引、切片）：字符串、列表、元组

　　3.映射访问：字典

存放元素个数：

　　1.容器类型（多个）：类表、元组、字典

　　2.原子（一个）：数字、字符串