基本语法
1.在Python中严格区分大小写 2.Python中的每一行就是一条语句，每条语句以换行结束 3.Python中每一行语句不要过长（规范中建议每行不要超过80个字符） "rulers":[80], 4.一条语句可以分多行编写，多行编写时语句后边以\结尾 5.Python是缩进严格的语言，所以在Python中不要随便写缩进 6.在Python中使用#来表示注释，#后的内容都属于注释，注释的内容将会被解释器所忽略 我们可以通过注释来对程序进行解释说明，一定要养成良好的编写注释的习惯 注释要求简单明了，一般习惯上#后边会跟着一个空格
1. 数值
10进制的数字不能以0开头
整型(int) 布尔值 (True False) 浮点型(float) 复数
2. 字符串
相同的引号之间不能嵌套，不能跨行
2.1 长字符串
使用三重引号来表示一个长字符串，三重引号可换行，并会保留字符串中的格式
s = '''锄禾日当午， 汗滴禾下土'''
2.2 转义字符
2.3 拼接字符串
字符串只能和字符串拼接，不能和其他类型的进行拼接，否则会报错
2.4 在创建字符串时，可在字符串中指定占位符
%s 在字符串中表示任意字符 %f 浮点数占位符 %d 整数占位符 b = 'hello %s' % '孙悟空' # hello world b = 'hello %s,hi %s' % ('tom','Kitty') # hello tom,hi kitty b = 'hello %3.5s' % 'abcdefg' %3s字符串的长度限制在3-5之间 hello abcde b = 'hello %.2f' % 123.456 # hello 123.46 b = 'hello %d' % 123.95 # 123
2.5 格式化字符串，通过在字符串前添加一个f来创建格式化字符串。在格式化字符串中可以直接嵌入变量
c = 12 d = f'abc {c}' # abc 12
2.6 多个参数
name = '孙悟空' print('欢迎',name,'光临！') # 欢迎孙悟空光临！
2.7 字符串的复制(将字符串和数字相乘)：解释器会将字符串重复指定的次数并返回
a = a * 20
2.8 空值 (None)
2.9 类型检查
type()用来检查值的类型,并将检查的结果作为返回值返回，可通过变量来接收函数的返回值
print( type(1) ) # <class 'int'> print( type(1.5) ) # <class 'float'> print( type(True) ) # <class 'bool'> print( type('hello') ) # <class 'str'> print( type(None) ) # <class 'NoneType'>
3. 对象 object
3.1 对象的结构
- 每个对象中都要保存三种数据 - id（标识） > id用来标识对象的唯一性，每一个对象都有唯一的id > 对象的id就相当于人的身份证号一样 > 可以通过id()函数来查看对象的id > id是由解析器生成的，在CPython中，id就是对象的内存地址 > 对象一旦创建，则它的id永远不能再改变 - type（类型） > 类型用来标识当前对象所属的类型 > 比如：int str float bool 。。。 > 类型决定了对象有哪些功能 > 通过type()函数来查看对象的类型 > Python是一门强类型的语言，对象一旦创建类型便不能修改 - value（值） > 值就是对象中存储的具体的数据 > 对于有些对象值是可以改变的 > 对象分成两大类，可变对象 不可变对象 可变对象的值可以改变 不可变对象的值不能改变 # int str bool None student={ 'name':'jack', 'age':18, 'height':170 }
3.2 类型转换
- 所谓的类型转换，将一个类型的对象转换为其他对象 - 类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新对象 类型转换的四个函数： int() 将其他的对象转换为整型，但不会对原来的变量产生影响 1.布尔值：True -> 1 ; False -> 0 2.浮点数：直接取整，省略小数点后的内容 3.字符串：合法的整数字符串，直接转换为对应的数字；如果不是合法的整数字符串，则报错； 4.对于其他不可转换为整型的对象(None)等，则报错； float() 将其他的对象转换为浮点数，但不会对原来的变量产生影响 1.布尔值：True -> 1.0 ; False -> 0.0 2.整数：转化成浮点数； 3.字符串：合法的浮点数字符串，直接转换为对应的数字；如果不是合法的浮点数字符串，则报错； 4.对于其他不可转换为整型的对象(None)等，则报错； str() 将其他的对象转换为字符串，但不会对原来的变量产生影响; 1.True -> 'True' ; False -> 'False' 2.123 -> '123' repr() 将其他的对象转换为表达式字符串，但不会对原来的变量产生影响; 1.对于所有表示空性的对象(0,None,'')都会转换为False,其余的转换为True
3.3 可变对象
- 每个对象中都保存了三个数据： id（标识） type（类型） value（值） - 列表就是一个可变对象 a = [1,2,3] - a[0] = 10 （改对象） - 这个操作是在通过变量去修改对象的值 - 这种操作不会改变变量所指向的对象 - 当我们去修改对象时，如果有其他变量也指向了该对象，则修改也会在其他的变量中体现 - a = [4,5,6] （改变量） - 这个操作是在给变量重新赋值 - 这种操作会改变变量所指向的对象 - 为一个变量重新赋值时，不会影响其他的变量 - 一般只有在为变量赋值时才是修改变量，其余的都是修改对象 == != 比较对象的值是否相等 is is not 比较对象的id是否相等(更加严格)
4. 运算操作符
- 运算符可以对一个值或多个值进行运算或各种操作 - 比如 + 、-、= 都属于运算符 - 运算符的分类： 1.算术运算符(+ - * /等) +:两个字符串之间进行加法运算，进行拼串操作； *：字符串和数字相乘，则对字符串进行复制操作，将字符串重复指定的次数； /:运算时结果总会返回一个浮点类型； //:整除，只会保留计算后的整数位，总会返回整型； **:幂运算，求一个值的几次幂； %:取模，求两个数相除的余数; 2.赋值运算符(= += %= //= %=等) 3.比较运算符（> >= <= == !=等）：比较两个值之间的关系，返回一个布尔值 在python中可对两个字符串进行大于（等于）或小于（等于）的运算，实际上比较的是字符串的Unicode编码，并且是逐位比较的；（如果不希望比较两个字符串的Unicode编码，则需要将其转换为数字然后再比较） 4.逻辑运算符 not 非 (一元) a = True b = not a print(b) #False a = 1 a = not a print(a) #False and 与 (二元)：只有在符号两侧的值都为True时，才会返回True,只要有一个False就返回False; Python中的与运算是短路的与，如果第一个值为False,则不再看第二个值 or 或 (二元)：Python中的或运算是短路的或，如果第一个值为True,则不再看第二个值 result = True or False print(result) #True 非布尔值的与或运算 当对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终返回原值 1 and 2 #2 1 or 2 #1 1 and 0 #0 1 and 0 #1 0 and None #0 0 and None #None 补充：逻辑运算符可以连着使用； 1 < 2 < 3 #相当于1 < 2 and 2 < 3 5.条件运算符（三元运算符） 语句1 if 条件表达式 else 语句2
5. 列表
- 列表是Python中的一个对象 - 对象（object）就是内存中专门用来存储数据的一块区域 - 之前我们学习的对象，像数值，它只能保存一个单一的数据 - 列表中可以保存多个有序的数据 - 列表是用来存储对象的对象 - 列表的使用： 1.列表的创建 2.操作列表中的数据 列表中存储的数据，称为元素 一个列表中可存储多个元素，也可在创建列表时，来指定列表中的元素 列表中可保存任意的对象 # myList = [10,'hello',[1,2],True,None,print] 通过索引获取列表中的元素，语法：myList[索引] 列表中的索引可以是负数，-1表示倒数第一个，-2表示倒数第二个 print(myList[-1]) # <built-in function print> len(),该函数可获取列表的长度 print(len(myList)) # 6 切片：从现有列表中，获取一个子列表 语法：列表[起始:结束] 1.通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素 2.做切片操作时，总会返回一个新的列表，不影响原来的列表 3.如果省略起始位置，则会从第一个元素开始截取 4.如果省略结束位置，则会一直截取到最后 5.如果起始位置和结束位置都省略，相当于创建了一个列表的副本 语法：列表[起始:结束:步长] 1.步长：每次获取元素的间隔，默认值是1 2.步长不能是0，但可为负数（从列表后部向前边取元素） num = [1,2,3,4,5,6,5,6] num[1:4:2] #[2,4] num[::3] #[1,4] num[::-1] #[6,5,6,5,4,3,2,1] + 可将两个列表拼接为一个列表 * 可将列表重复指定的次数 in 用来检查指定元素是否存在于列表中，如果存在 返回True,否则返回False print(5 in num) #True not in 用来检查指定元素是否存在于列表中，如果存在 返回False,否则返回True min() 获取列表中的最小值 print(min(num)) #1 max() 获取列表中的最大值 方法一:必须通过 对象.方法() 的形式调用 index() 获取指定元素在列表中的第一次出现时的索引，若没有该元素则报错 index()的第二个参数，表示查找的起始位置，第三个参数，表示查找的结束位置 num.index(2) #1 count() 统计指定元素在列表中出现的次数 num.count(5) #2 修改列表 newList = ['hi',5,10,'haha','2'] 1.通过索引修改元素 newLsit[0] = 'hello' 2.通过del删除元素 del newList[2] 3.通过切片修改列表，在给切片赋值时，只能使用序列 newList[0:2] = [1,2,3] print(newList) #[1,2,3,10,'haha','2'] 向索引为0的位置插入元素 newList[0:0] = ['你好'] print(newList) #['你好','hi',5,10,'haha','2'] 当设置步长时，序列中元素的个数必须和切片中元素的个数一致 newList[::2] = [8,8,8] print(newList) #[8,5,8,'haha',8] 4.通过切片删除元素 del newList[0:2] del newList[::2] newList[0:2] = [] 方法二： num1 = [1,2,3,4,5] num2 = [-1,1,5,2,1] 1.append() 向列表的最后添加一个元素 num1.append(6) #[1,2,3,4,5,6] 2.insert() 向列表的指定位置插入一个元素 num1.insert(2,6) #[1,2,6,3,4,5] 3.extend() 使用新的序列来扩展当前序列。需要一个序列作为参数，将该序列中的元素添加到当前列表中。 num1.extend([6,7,8]) #[1,2,3,4,5,6,7,8] 4.clear() 清空序列 num1.clear() #[] 5.pop() 根据索引删除被返回被删除的元素 num1.pop(2) #3 num1 = [1,2,4,5] num1.pop() 删除最后一个元素 #[1,2,3,4] 6.remove() 删除指定值的元素，如果相同值的元素有多个，只会删除第一个，无返回值。 num1.remove(2) #[1,3,4,5] 7.reverse() 反转列表 num1.reverse() #[5,4,3,2,1] 8.sort() 对列表中的元素排序，默认是升序排列 num2.sort() #[-1,1,1,2,5] 降序:num2.sort(reverse = True) #[5,2,1,1,-1] 遍历列表 num2 = [1,2,3,4,5,6,7,8] 1.通过while循环来遍历列表 i = 0 while i < len(num2): print(num2[i]) i += 1 2.通过for循环来遍历列表 语法： for 变量 in 序列: 代码块 for循环的代码会执行多次，序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变 量，可通过变量来获取列表中的元素。for()循环除了创建方式外，其余的都和while一样，包括else break continue都可在for循环中使用。 for i in num2: print(i) 3.range() 用来生成一个自然数的序列，可创建一个指定次数的for循环 三个参数：1.起始位置(可省略，默认为0) 2.结束位置 3.步长(可省略，默认为1) for i range(20): print(i)
6. 序列 sequence
- 序列是Python中最基本的一种数据结构 - 数据结构指计算机中数据存储的方式 - 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引） 并且序列中的数据会按照添加的顺序来分配索引 - 序列的分类： 可变序列（序列中的元素可以改变）： > 列表（list） 不可变序列（序列中的元素不能改变）： > 字符串（str） > 元组（tuple） 通过list()函数将其他的序列转换为list a = 'haha' b = list(a) #['h','a','h','a']
7. 元组 tuple
元组是不可变序列（不能尝试为元组中的元素重新赋值），它的操作方式基本上和列表一致. 1.创建元组 当元组不是空元组时，括号可省略。 如果元组不是空元组，它里面至少要有一个, myTuple = (1,2,3,4) 2.元组的解构，将元组中每一个元素都赋值给一个变量 a,b,c,d = myTuple 2.1 交互a和b的值 a,b = (b,a) 2.2 对元组进行解构时，变量的数量必须和元组中的元素的数量一致，可在变量的前面添加一个*，这个变量将会获取 元组中所有剩余的元素。不能同时出现两个或以上的*变量。 a,b,*c = myTuple # a = 1 b = 2 c = [3,4]
8. 字典 dict
- 字典属于一种新的数据结构，称为映射（mapping） - 字典的作用和列表类似，都是用来存储对象的容器 - 列表存储数据的性能很好，但是查询数据的性能的很差 - 在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素 - 在查询元素时，字典的效率是非常快的 - 在字典中可以保存多个对象，每个对象都会有一个唯一的名字 这个唯一的名字，我们称其为键（key），通过key可以快速的查询value 这个对象，我们称其为值（value） 所以字典，我们也称为叫做键值对（key-value）结构 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item） 1.创建字典 1.1 使用{}创建字典，语法：{key:value,key:value} 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple等)，但一般使用str 字典的键是不能重复的，如果重复 后面的会替换前边的 a = { 'name':'孙悟空', 'category':'猴子' } 1.2 使用dict()函数创建字典 每个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串） b = dict(name = '猪八戒',age = 20,sex = '男') 1.3 将一个包含有双值子序列的序列转换为字典 双值序列，序列中只有两个值，[1,2] ('a',3) 'ab' 子序列，如果序列中的元素也是序列，称这个元素为子序列 [(1,2),('a','b')] c = dict([('name','沙僧'),('age',30)]) 2.根据键获取值 2.1 语法：d[key] 如果键不存在，会报错 print(a['name']) # 孙悟空 2.2 get(key[,default]) 用来根据键来获取字典中的值，如果获取的键在字典中不存在，则返回None。也可指 定一个默认值，作为第二个参数，这样获取不到值时 将返回默认值 print(a.get('hello','默认值')) # 默认值 3.len() 获取字典中键值对的个数 4.in 检查字典中是否包含指定的键 print('name' in a) #True not in 检查字典中是否不包含指定的键 5.修改字典 5.1 语法：a[key] = value 如果key存在则覆盖，不存在则添加 a['name'] = '牛魔王' # 修改字典中的key-value a['address'] = '火焰山' #向字典中添加key-value 5.2 setdefault(key[,default]) 用来向字典中添加key-value 如果key已经存在于字典中，则返回key的值，不会对字典做任何操作 如果key不存在，则向字典中添加这个key，并设置value result = a.setdefault('hihi','红孩儿') 5.4 update([other]) 将其他字典中的key-value添加到当前字典中。 如果有 重复的key,则后面的会替换掉当前的 a.update(b) print(a) #{'name': '猪八戒', 'category': '猴子', 'age': 20, 'sex': '男'} 6.删除 6.1 使用 del 删除字典中的 key-value del a['name'] a = {'category':'猴子'} 6.2 popitem() 随机删除字典里的一个键值对，一般都会删除最后一个键值对 删除之后，会将删除的key-value作为返回值返回，返回的是一个元组，元组中有两个元素，第一个元素是 删除的key,第二个是删除的value。 a.popitem() 6.3 pop(key[,default]) 根据key删除字典中的key-value，将被删除的value返回。 如果删除不存在的key，会抛出异常。如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回 默认值。 a.pop('name') a.pop('hh','这是默认值') 6.4 clear() 用来清空字典 d.clear() 7. copy() 该方法用于对字典进行浅复制 复制以后的对象，和原对象是独立，修改一个不会影响另一个 注意：浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制 a.copy() 8.遍历字典 d = {'name':'孙悟空','age':18,'sex':'男'} 8.1 keys() 返回字典里的所有的key。该方法会返回一个序列，序列中保存有字典的所有的键。 通过遍历keys()获取所有键 for k in d.keys(): print(k,d[k]) 8.2 values() 返回一个序列，序列中保存有字典的左右的值 8.3 items() 返回字典中所有项。 它会返回一个序列，序列中包含有双值子序列。双值分别是：字典中的key和value for k,v in d.items(): print(k,'=',v) # name = 孙悟空 age = 18 sex = 男
9. 集合 set
- 集合和列表非常相似 - 不同点： 1.集合中只能存储不可变对象 2.集合中存储的对象是无序（不是按照元素的插入顺序保存） 3.集合中不能出现重复的元素 1.创建 1.1 使用{}创建集合 s = {1,2,6,4,7} 1.2 使用 set() 函数创建集合 创建空集合 s = set() 1.3 通过set()将序列和字典转换为集合 s = set([1,2,3,4,1,1,2]) # {1,2,3,4} s = set('hello') # {'h','o','l','e'} # 使用set()将字典转化为集合时，只会包含字典中的键 s = set({'a':1,'b':2,'c':3}) # {c,a,b} 2.使用 in 和 not in 检查集合中的元素 3.使用 len() 获取集合中元素的数量 4. add() 向集合中添加元素 s.add(10) 5. update() 将一个集合中的元素添加到当前集合中，可传递序列或字典作为参数，字典只会使用键 s2 = set('hello') s.update(s2) # {'h', 1, 2, 'o', 4, 'e', 6, 7, 'l'} 6.删除 6.1 pop() 随机删除并返回一个集合中的元素 6.2 remove() 删除集合中的指定元素 s.remove(2) 6.3 clear() 清空集合 7.copy()对集合进行浅复制 8.集合运算：在对集合做运算时，不会影响原来的集合，而是返回一个运算结果 s1 = {1,2,3,4,5} s2 = {3,4,5,6,7,8} 8.1 & 交集运算 result = s1 & s2 # {3,4,5} 8.2 | 并集运算 result = s1 | s2 # {1,2,3,4,5,6,7,8} 8.3 - 差集 result = s1 - s2 # {1,2} 8.4 ^ 异或集 result = s1 ^ s2 # {1,2,6,7,8,9} 8.5 <= 检查一个集合是否为另一个集合的子集 result = s1 <= s2 # False result = {1,2,3} <= {1,2,3} # True 8.6 < 检查一个集合是否为另一个集合的真子集 result = {1,2,3} < {1,2,3} # False 8.7 >= 检查一个集合是否为另一个的超集 8.8 > 检查一个集合是否为另一个的真超集
