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*10a=a+1 a+=1结果是布尔值

比较运算

a=1>5逻辑运算

a=1>6 or 1==1成员运算

a='邹’ in'邹雨晴'

10.基本数据类型

数字

-int

将字符串转换为数字

a="123"

print(type(a),a) 　　#输出a的类型、a

b=int(a) 　　 #将字符串类型转换为数字类型

print(type(b),b)　　 #输出b的类型、b

num="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*********

*********lebronjames

000000000lebronjames

*.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>>>chenjian

chenjian

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.原子（一个）：数字、字符串