初进python世界之数据类型
本章划分：
基本运算符
常用数据类型：
字符串（Str）
数字（Digit）
列表（List）
元组（Tuple）
集合（Set）
字典（Dict）
布尔（bool）
Python文件处理
基本运算符
当然，在讲数据类型之前，先了解一下Python的基本运算符：
运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算和位运算。以下分别学习每个运算符：
一、算数运算：
| 运算符 | 描述 | 实例 |
| + | 普通的加法运算 | 10+2=12 |
| - | 普通的减法运算 | 10-2=8 |
| * | 普通的乘法运算 | 10*2=20 |
| / | 普通的除法运算 | 10/2=5 |
| % | 取模运算，两数相除，取余数 | 10%2=0；10%3=1 |
| // | 取整除，两数相除，无论是否整除，只取商的整数部分，（没有四舍五入之说） | 10.0//2.0=5.0；10//3=3；18//3=6 |
| ** | 求幂运算，取一个数的幂次方 | 10**2=100 |
二、比较运算
说明： 以下比较的是两个对象的值。
| 运算符 | 描述 | 实例 |
| == | 等于，比较两个对象是否相等,返回True或者False | 如果a=10,b=10,那么a==b,返回True |
| != | 不等于，比较两个对象是否不相等,返回True或者False | 如果a=10,b=10,那么a!=b,返回False |
| <> | 不等于，比较两个对象是否不相等,返回True或者False，不常用 | 如果a=10,b=10,那么a<>b,返回False |
| > | 大于，比较a对象是否大于b对象,返回True或者False | 如果a=10,b=10,那么a>b,返回False |
| < | 小于，比较比较a对象是否小于b对象,返回True或者False | 如果a=10,b=10,那么a<b,返回False |
| >= | 大于等于，比较a对象是否大于等于b对象,返回True或者False | 如果a=10,b=10,那么a=>b,返回True |
| <= | 小于等于，比较a对象是否小于等于b对象,返回True或者False | 如果a=10,b=10,那么a<=b,返回True |
三、赋值运算
| 运算符 | 描述 | 实例 |
| = | 简单的赋值运算符，元素1赋值给元素2 | c=a+b,c=10+b等这些都属于简单的赋值运算 |
| += | 加法赋值运算符，先相加，再赋值，多用于循环语句中元素的自加 | c+=a相当于c=c+a |
| -= | 减法赋值运算符，先相减，再赋值，多用于循环语句中元素的自减 | c-=a相当于c=c-a |
| *= | 乘法赋值运算符，先相乘，再赋值，多用于循环语句中元素的自乘 | c*=a相当于c=c*a |
| /= | 除法赋值运算符，先相除，再赋值，多用于循环语句中元素的自除 | c/=a相当于c=c/a |
| %= | 取模赋值运算符，先取模，再赋值 | c%=a相当于c=c%a |
| **= | 取幂赋值运算符，先取幂，再赋值 | c**=a相当于c=c**a |
| //= | 取整除赋值运算符，先取整除，再赋值 | c//=a相当于c=c//a |
四、逻辑运算
| 运算符 | 描述 | 实例 |
| and | ‘与’，并且的意思，两边的元素都为真即返回真 | a and b：a为真，b为假，返回False，a为真，b为真 ，返回True |
| or | ‘或’，或者的意思，两边的元素只要有一个为真，即返回真 | a or b：a为真，b为假，返回True，a为假，b为假 ，返回False |
| not | ‘非’，相反的意思，如果是真的，返回假，如果是假的，返回真 | not a：a为真，返回False，a为假，返回True |
五、成员运算
| 运算符 | 描述 | 实例 |
| in | 在：如果对象a能在对象b中找到，则返回True，否则，返回False | x in y ;如果x在y中，则会返回True，否则为False |
| not in | 不在：如果对象a能在对象b中找不到，则返回True，否则，返回False | x not in y ;如果x不在y中，则会返回True，否则为False |
六、身份运算
说明只列出两个比较常用的，身份运算比较的是对象的name、id、value，以下比较的是两个对象的id（id相同，即type相同，值相同）
| 运算符 | 描述 | 实例 |
| is | 是：如果对象a和对象b的id相同，则返回True，否则，返回False | x is y ;如果x和y的id相同，则会返回True，否则为False |
| is not | 不是：如果对象a和对象b的id不相同，则返回True，否则，返回False | x is not y ;如果x和y的id不相同，则会返回True，否则为False |
七、位运算
比较二进制位，例如a=30,b=11 ，（转换二进制函数bin()）二进制表示就是a=11110,b=1011。位运算比较复杂，可以仅作了解。
| 运算符 | 描述 | 实例 |
| & | 按位与运算符：如果存在于两个对象中，则复制位到结果中。例如参与运算的两个值，从右到左进行比较，如果相应位都为1，则结果为1，只要有一个为0，结果即为0 | a&b,从右到左进行比较，结果即为1010，a比b多一位，a从左到右的第一位1在b的相应位置是空，即没有，则结果也是没有。 |
| | | 按位或运算符：只要存在于其中一个对象中，则复制位到结果中。例如参与运算的两个值，从右到左比较，如果相应位置中有一个是1，则结果为1 | a|b,从右到左进行比较，结果即为11111，同样a从左到右的第一位1在b的相应位置是空，即没有，但是结果仍然是1. |
| ^ | 按位异或运算符：如果对象对应的的二进位相异时，复制位。例如参与运算的两个值，从右到左进行比较，如果相应位不一样，即一个为0，一个为1，则结果为1。 | a^b,从右到左进行比较，结果即为10101，a比b多一位，a从左到右的第一位1在b的相应位置是空，结果相异，则为1。 |
| ~ | 按位取反运算符：一元的，具有翻转效果。例如参与运算的一个值，把相应位置的1变为0,0变为1 | ~a，结果即为-31，二进制为11111， 在一个有符号二进制数的补码形式 |
| << | 左移动运算符：左操作数的值由右操作数指定的位数左移。例如参与运算的两个值，左边的数的各二进制位全部左移，左移位数由右边的数值决定，高位丢弃，低位补0 | a<<b,结果1111000000000000，因为b=11，所以左移了11位，低位补0 |
| >> | 右移动运算符：左操作数的值由右操作数指定的位数右移。例如参与运算的两个值，左边的数的各二进制位全部右移，右移为数由右边的数值决定，高位丢弃，低位补0 |
a>>b,结果0，因为b=11，所以右移了11位，高位丢弃，另如果 b=3，则结果为11 |
常用数据类型
字符串（str）
字符串的声明有三种方式：单引号，双引号和三引号（三个单引号或者三个双引号）。不可变（可hash）
例如：
>>> print('hello word!') hello word! >>> print("hello word!") hello word! >>> print('''hello word!''') hello word! >>> print("""hello word!""") hello word! >>>
字符串根据索引的一些切片操作：
>>> str = 'hello world!' >>> print(str) # 输出字符串 hello world! >>> print(str[0:-1]) # 输出第一个到倒数第二个的所有字符（字符串具有顾头不顾尾的特性，所以不会取到最后一个字符） hello world >>> print(str[0]) # 输出字符串第一个字符 h >>> print(str[2:5]) # 输出从第三个开始到第五个的字符 llo >>> print(str[2:]) # 输出从第三个开始后的所有字符 llo world! >>> print(str * 2) # 输出字符串两次 hello world!hello world! >>> print(str + "TEST") # 连接字符串 hello world!TEST >>>
移除空格 strip,lstrip,rstrip
>>> str=' hello world!' >>> sea='hello world!***' >>> print(str.strip()) #默认移除全部空格 hello world! >>> print(sea.strip('*')) #移除指定特殊字符* hello world! >>> print(str.lstrip()) #默认移除左边空格 hello world! >>> print(sea.rstrip('*')) #移除右边指定特殊字符* hello world! >>>
切分 split,rsplit
>>> str='root:x:0:0::/root:/bin/bash' >>> print(str.split()) #默认以空格为分隔符 ['root:x:0:0::/root:/bin/bash'] >>> print(str.split(':',1)) #以冒号为分隔符,只分割第一个冒号，默认分割全局 ['root', 'x:0:0::/root:/bin/bash'] >>> print(str.rsplit(':',2,))#从右边开始分割，分割从右边数的前两个冒号 ['root:x:0:0:', '/root', '/bin/bash'] >>>
取字符串长度 len
>>> str='hello world!' >>> print(len(str)) #取字符串的长度，等价于print(str.__len__()) 12 >>> print(str.__len__()) 12 >>>
判断开头和结尾字符 startswith,endswith
>>> str='seagull' >>> print(str.endswith('l')) #判断结尾，如果正确，则返回True，否则返回False True >>> print(str.endswith('l',1,3)) #指定开头和结尾 False >>> print(str.startswith('s')) #判断开头，如果正确，则返回True，否则返回False True >>> print(str.startswith('s',3,4)) ##指定开头和结尾 False >>>
字符串的替换操作 replace
>>> str='seagull' >>> print(str.replace('l','9')) #字符串的替换，将字母l替换为数字9，默认替换全局 seagu99 >>> print(str.replace('l','9',1)) #字符串的替换，指定只将第一个找到的字母l替换为9 seagu9l >>>
format的三种玩法
>>> name='seagull' >>> age=18 >>> hobby='eat' >>> print('我是%s，今年%s岁，爱好%s'%(name,age,hobby)) #%s的传参法 我是seagull，今年18岁，爱好eat >>> print('我是{}，今年{}岁，爱好{}'.format('seagull','18','eat')) #花括号传参，和%s有点相似 我是seagull，今年18岁，爱好eat >>> print('我是{}，今年{}岁，爱好'.format('seagull','18','eat')) #后面的传参可以比前面的花括号多，但是不能比前面的花括号少，否则会报错 我是seagull，今年18岁，爱好 >>> print('我是{1}，今年{0}岁，爱好{0}'.format('seagull','18','eat')) #花括号里面写数字传参法，后面的参数默认指定了顺序 ，花括号里面可以写指定的数字镜像传参 我是18，今年seagull岁，爱好seagull >>> print('我是{name}，今年{age}岁，爱好{hobby}'.format(name='seagull',age='18',hobby='eat')) #指定参数，用一个等于号赋 值 我是seagull，今年18岁，爱好eat >>>
查找和统计：find,rfind,index,rindex,count
>>> str='seagull' >>> print(str.find('l')) #查找字符l的下标 5 >>> print(str.find('b')) #查找字符b的下标,找不到返回-1 -1 >>> print(str.index('l')) #查找字符l的下标 5 >>> print(str.index('b')) #查找字符d的下标,找不到会报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: substring not found >>> print(str.rfind('l')) #从右边开始查找字符l的下标 6 >>> print(str.rindex('l')) #从右边查找字符l的下标 6
>>> print(str.count('l')) #统计字符串中包含字符的个数，可以指定范围查找 2 >>> print(str.count('l',1,4)) #统计字符串中包含字符的个数 0 >>>
连接字符串 join （#可迭代对象必须都是字符串）
>>> str=' ' #给tag赋值为空格 >>> print(str.join(['seagull','is','looker'])) #插入字符，每个字符串之间以空格分割 seagull is looker >>> str='a' #给tag赋值为a >>> print(str.join(['seagull','is','looker'])) #插入字符，每个字符串之间以a分割 seagullaisalooker >>> str='9' >>> print(str.join(['seagull','is','looker'])) #插入字符，每个字符串之间以数字9分割 seagull9is9looker >>> str='9' >>> print(str.join(['seagull''is''looker'])) #插入字符，每个字符串之间没有分割 seagullislooker >>> str='seagull' >>> print(":".join(str)) #以冒号为分隔符，将字符串分割 s:e:a:g:u:l:l >>>
显示打印 center,ljust,rjust,zfill
>>> str='seagull' >>> print(str.center(30,'*')) #30个占位符，居中显示，字符不足时用*填充，默认是用空格填充 ***********seagull************ >>> print(str.ljust(10,'1')) #10个占位符，靠左显示，字符不足用数字1填充，默认空格 seagull111 >>> print(str.rjust(10)) #10个占位符，靠右显示，字符不足默认空格填充，也可指定 seagull >>> print(str.zfill(10)) #10个占位符，靠右显示，字符不足用0填充,不能自己指定 000seagull >>>
转换tab键为空格 expandtabs
>>> str='sea\tgull' >>> print(str) sea gull >>> print(str.expandtabs(1)) sea gull >>>
字母大小写转换 lower ，upper ，captalize,swapcase,title
str='seaGULL' print(str.lower())#将包含的大写字母转换成小写 print(str.upper())#将包含的小写字母转换成大写
>>> str1='sea GULL' >>> str2='sea_Gull' >>> print(str1.capitalize()) #只首字母大写，其他的均小写 Sea gull >>> print(str2.capitalize()) Sea_gull >>> print(str1.swapcase()) #大小写翻转，大写变小写，小写变大写 SEA gull >>> print(str2.swapcase()) SEA_gULL >>> print(str1.title()) #标题，每个单词的首字母大写，其他的小写 Sea Gull >>> print(str2.title()) Sea_Gull >>>
is数字系列（Python3），正确返回True，否则返回False
>>> num1=b'4' #bytes >>> num2=u'4' #unicode,python3中无需加u就是unicode >>> num3='四' #中文数字 >>> num4='Ⅳ' #罗马数字 >>> #isdigt:bytes,unicode，常用 ... print(num1.isdigit()) True >>> print(num2.isdigit()) True >>> print(num3.isdigit()) False >>> print(num4.isdigit()) False >>> #isdecimal:uncicode ... #bytes类型无isdecimal方法 ... print(num2.isdecimal()) True >>> print(num3.isdecimal()) False >>> print(num4.isdecimal()) False >>> #isnumberic:unicode,中文数字,罗马数字 ... #bytes类型无isnumberic方法 ... print(num2.isnumeric()) True >>> print(num3.isnumeric()) True >>> print(num4.isnumeric()) True >>> >>> #浮点型不能判断 ... num5='4.3' >>> num6='1/2' >>> print(num5.isdigit()) False >>> print(num5.isdecimal()) False >>> print(num5.isnumeric()) False >>> print(num6.isdigit()) False >>> print(num6.isdecimal()) False >>> print(num6.isnumeric()) False >>>
is其他系列，正确返回True，否则为False
>>> str1='seagull' >>> str2='seagu123' >>> print(str1.isalnum()) #判断字符串是否由只由字母和数字或者两者共同组成，是返回True，否则返回False True >>> print(str2.isalnum()) True >>> print(str1.isalpha()) #判断字符串是否只由字母组成，是返回True，否则返回False True >>> print(str2.isalpha()) False >>> str3='a' >>> str4='1' >>> print(str3.isidentifier())#判断单词是否为字母，或者是否包含关键字（字母，下划线），是就返回True True >>> print(str4.isidentifier())#不能包含的有特殊字符（*，空格，=，数字等，） False >>> str1='SEAGUll' >>> str2='seagu123' >>> print(str1.islower()) #判断包含的字母是否全部为小写字母，是就返回True False >>> print(str2.islower()) True >>> str1='SEAGUll' >>> str2='SEAGULL123' >>> print(str1.isupper())#判断包含字母是否全部是大写，是就返回True False >>> print(str2.isupper()) True >>> str1=' ' >>> str2='' >>> print(str1.isspace())#判断是否为空格，是就返回True True >>> print(str2.isspace()) False >>> str1='SEAGUll' >>> str2='Seagull123' >>> print(str1.istitle())#判断是否为标题（首字母是否大写，单词的首字母大写），如果是就返回True False >>> print(str2.istitle()) True >>>
字符串小练习
# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分） name = " aleX" # 1) 移除 name 变量对应的值两边的空格,并输出处理结果 print(name.strip()) # 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果 print(name.startswith('al')) # 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果 print(name.endswith('X')) # 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 print(name.replace('l','p')) # 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。 print(name.split('l')) # 6) 将 name 变量对应的值变大写,并输出结果 print(name.upper()) # 7) 将 name 变量对应的值变小写,并输出结果 print(name.lower()) # 8) 请输出 name 变量对应的值的第 2 个字符? print(name[1]) # 9) 请输出 name 变量对应的值的前 3 个字符? print(name[0:3]) # 10) 请输出 name 变量对应的值的后 2 个字符? print(name[-2:]) # 11) 请输出 name 变量对应的值中 “e” 所在索引位置? print(name.find('e')) print(name.index('e')) # 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。 print(name[:-1]) print(name.rstrip('X')) print(name.replace('X','')) print(name.split('X')[0])
数字（Digit）
包括整数（int），浮点数（float），长整型（long） ，不可变（可hash）
删除数字对象引用
>>> a=1 >>> b=2 >>> c=3 >>> print(a) 1 >>> del a >>> print(a) #被删除后再次打印就好报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'a' is not defined >>>
数字类型转换
int(x [,base]) #将x转换为一个整数 float(x ) # 将x转换到一个浮点数 complex(real [,imag]) #创建一个复数 str(x) #将对象x转换为字符串 repr(x) #将对象x转换为表达式字符串 eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象 tuple(s) #将序列s转换为一个元组 list(s) #将序列s转换为一个列表 chr(x) #将一个整数转换为一个字符 unichr(x) #将一个整数转换为Unicode字符 ord(x) #将一个字符转换为它的整数值 hex(x) #将一个整数转换为一个十六进制字符串 oct(x) #将一个整数转换为一个八进制字符串
数字函数
abs(x) #返回数字的绝对值，如abs(-10) 返回 10 ceil(x) # 返回数字的上入整数，如math.ceil(4.1) 返回 5 cmp(x, y) #如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 exp(x) #返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 fabs(x) #返回数字的绝对值，如math.fabs(-10) 返回10.0 floor(x) #返回数字的下舍整数，如math.floor(4.9)返回 4 log(x) #如math.log(math.e)返回1.0,math.log(100,10)返回2.0 log10(x) #返回以10为基数的x的对数，如math.log10(100)返回 2.0 max(x1, x2,...) # 返回给定参数的最大值，参数可以为序列。 min(x1, x2,...) #返回给定参数的最小值，参数可以为序列。 modf(x) #返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 pow(x, y) x**y #运算后的值。 round(x [,n]) #返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 sqrt(x) #返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j
列表（List）
可以定义多个变量，有序的，可变（不可hash）类型，
索引
>>> lis=['seagull',18,'eat'] >>> print(lis[0]) seagull >>>
>>> lis=['seagull',18,'eat'] >>> print(lis.index(18)) 1 >>>
切片
>>> lis=['seagull',18,'eat'] >>> print(lis[:-1]) ['seagull', 18] >>>
追加
>>> str=['seagull',18] >>> str.append('eat') >>> print(str) ['seagull', 18, 'eat'] >>>
>>> str=['seagull',18] >>> str.extend('eat') #extend将引号里面的字符串分成单个字符，逐个添加，并且只能添加字符串 >>> print(str) ['seagull', 18, 'e', 'a', 't'] >>> str.extend(['sea','dongdong']) #如果添加列表，需要表明添加的是一个列表 >>> print(str) ['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong'] >>> str.extend({'hobby':'eat'}) #无法添加字典,但是可以将字典里面的冒号换成逗号添加多个列表 >>> print(str) ['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby'] >>> str.extend(('lele','honghong')) #小括号的形式添加列表 >>> print(str) ['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong'] >>>
删除
>>> str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong'] >>> str.pop() #索引的方式删除列表数据，不指定默认从右到左开始删除 'honghong' >>> print(str) ['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele'] >>> str.pop(0) #指定索引，删除指定删除项 'seagull' >>> print(str) [18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele'] >>> str.remove('hobby') #通过指定字符串的方式删除 >>> print(str) [18, 'e', 'a', 't', 'sea', 'dongdong', 'lele'] >>> str=[] #清空列表 >>> print(str) [] >>> del str #删除列表 >>> print(str) <class 'str'> >>>
长度
>>> str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong'] >>> print(len(str)) 10 >>>
循环
str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong'] for index in range(len(str)): #根据列表的长度进行循环。range，指定范围循环 print(str[index]) # range(start,end,step) # 参数含义：start：计数从start开始，默认从0开始。 # end：计数到end计数，但不包括end。 # step：每次跳跃的间距，默认为1 #循环输出结果： seagull 18 e a t sea dongdong hobby lele honghong
str = ['seagull', 'dongdong', 'hobby', 'lele', 'honghong'] for key,v in enumerate(str): print(key,end='：') print(v) # enumerate()是python的内置函数 # enumerate在字典上是枚举、列举的意思 # 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值 # enumerate多用于在for循环中得到计数 #得到的结果： 0：seagull 1：dongdong 2：hobby 3：lele 4：honghong
包含in
>>> str = ['seagull', 'dongdong', 'hobby', 'lele', 'honghong'] >>> if 'seagull' in str: ... print('ok') ... ok >>>
列表排序sort，sorted，reverse
#sort正向排序,直接修改源列表 >>> a=[5,4,3,2,1] >>> a.sort() >>> print(a) [1, 2, 3, 4, 5] >>>
>>> #sorted正向排序，可以保留源列表，生成新列表 ... a=[5,4,3,2,1] >>> b=sorted(a) >>> print(b) [1, 2, 3, 4, 5] >>> #sorted可以用在任何数据类型的序列中，返回的总是一个列表形式 ... b=sorted('iplaypython.com**') >>> print(b) ['*', '*', '.', 'a', 'c', 'h', 'i', 'l', 'm', 'n', 'o', 'o', 'p', 'p', 't', 'y', 'y'] >>>
>>> #reverse反转排序,直接修改源文件 ... a = [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> a.reverse() >>> print(a) [9, 8, 7, 6, 5, 4, 3, 2, 1] >>>
#reversed a=[5,4,3,2,1] for i in reversed(a): print(i)
切片方式的逆转
>>> mystring="54321" >>> mytuple=(5,4,3,2,1) >>> mylist=[5,4,3,2,1] >>> mystring[::-1] '12345' >>> mytuple[::-1] (1, 2, 3, 4, 5) >>> mylist[::-1] [1, 2, 3, 4, 5] >>>
小练习
# 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量 # 模拟队列 # 模拟堆栈 data=['alex',49,[1900,3,18]] sea={'name':data[0],'age':data[1],'data':data[2]} print(sea)
元组（Tuple）
用来存储多个值，有序的，不可变（可哈希） 类型，可以当做字典的key值。
索引
>>> sea=('seagull',18,'eat') >>> print(sea[0]) seagull >>> print(sea.index('seagull')) 0 >>>
切片
sea = ('seagull', 18, 'eat') print(sea[:-1])
循环
sea = ('seagull', 18, 'eat') for tuple in sea: print(tuple)
长度
>>> sea = ('seagull', 18, 'eat') >>> print(len(sea)) 3 >>>
包含in
sea = ('seagull', 18, 'eat') if 'seagull' in sea: print('ok')
小练习
#简单购物车：实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入 #升级要求 # 要求用户输入总资产，例如：2000 # 显示商品列表，让用户根据序号选择商品，加入购物车 # 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。 # 附加：可充值、某商品移除购物车 msg_dic={ 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, }
goods = [ {"name": "电脑", "price": 1999}, {"name": "鼠标", "price": 10}, {"name": "游艇", "price": 20}, {"name": "美女", "price": 998}, ] option = [ '<清空购物车，重新选择商品>', '<移除购物车内某一商品>', '<退出本次购物>' ] cart=[] total_asscts=input('请输入你的账户总额：') if not total_asscts.isdigit() and len(total_asscts)==0: print('输入非法字符，请重新输入！') else: coumt=0 tag=True while tag: for list in goods: print(goods.index(list),end=':') print(list) spid=input('请从以上商品中选择你想要购买的商品，输入商品序号\n >>：') coumt1=input('请输入你购买此商品的个数\n >>：') if spid.isdigit() and coumt1.isdigit(): for item in goods[int(spid)].items(): cart.append(item) cart.append(('number',coumt1)) coumt= int(coumt) + int((goods[int(spid)]['price'] * int(coumt1))) print('你购买商品的信息为：{name}'.format(name=cart)) while tag: print('购物清单：{}'.format(cart)) result=input('请问是否继续选择商品？[y|n]') if result == 'y': break else: if int(total_asscts)<coumt: print('商品总额：{}，你的余额：{}'.format(coumt,total_asscts)) result=input('你的余额不足，请问是否充值？[y|n]') if result == 'y': total_asscts=int(total_asscts)+int(input('请输入充值数额：')) print('账户余额为{}'.format(total_asscts)) result = input('请问是否购买？[y|n]') if result == 'y': if int(total_asscts)<coumt: print('你的余额充值不足，被强制退出，欢迎再次光临！') tag=False else: total_asscts =int(total_asscts) - coumt print('购买成功,你的余额：{}'.format(total_asscts)) print('你的购买清单为：{}，欢迎下次光临！'.format(cart)) cart=[] tag=False else: for key in option: print(option.index(key),end=':') print(key) sku=input('请选择以上序号进行操作：') if sku=='0': cart=[] continue elif sku == '1': print('你的购物清单是：\n {}'.format(cart)) del_good = input('请选择你要移除的商品：') if del_good == '电脑': cart.pop(cart.index(('name', '电脑')) + 1) cart.pop(cart.index(('name', '电脑')) + 1) cart.remove(('name', '电脑')) elif del_good == '鼠标': cart.pop(cart.index(('name', '鼠标')) + 1) cart.pop(cart.index(('name', '鼠标')) + 1) cart.remove(('name', '鼠标')) elif del_good == '游艇': cart.pop(cart.index(('name', '游艇')) + 1) cart.pop(cart.index(('name', '游艇')) + 1) cart.remove(('name', '游艇')) elif del_good == '美女': cart.pop(cart.index(('name', '美女')) + 1) cart.pop(cart.index(('name', '美女')) + 1) cart.remove(('name', '美女')) else: print('输入错误，已经自动退出！') else: tag = False else: print('余额不足，已被强制退出！') tag=False else: print('商品总额：{}，你的余额：{}'.format(coumt, total_asscts)) result = input('请问是否购买？[y|n]') if result=='y': total_asscts = int(total_asscts) - coumt print('购买成功,你的余额：{}'.format(total_asscts)) print('你的购买清单为：{}，欢迎下次光临！'.format(cart)) cart = [] tag = False else: for key in option: print(option.index(key), end=':') print(key) sku = input('请选择以上序号进行操作：') if sku == '0': cart = [] continue elif sku == '1': print('你的购物清单是：\n {}'.format(cart)) del_good=input('请选择你要移除的商品：') if del_good=='电脑': cart.pop(cart.index(('name', '电脑'))+1) cart.pop(cart.index(('name', '电脑'))+1) cart.remove(('name', '电脑')) elif del_good=='鼠标': cart.pop(cart.index(('name', '鼠标'))+1) cart.pop(cart.index(('name', '鼠标'))+1) cart.remove(('name', '鼠标')) elif del_good=='游艇': cart.pop(cart.index(('name', '游艇'))+1) cart.pop(cart.index(('name', '游艇'))+1) cart.remove(('name', '游艇')) elif del_good=='美女': cart.pop(cart.index(('name', '美女'))+1) cart.pop(cart.index(('name', '美女'))+1) cart.remove(('name', '美女')) else: print('输入错误，已经自动退出！') else: tag=False else: print('输入有误，请重新确认并输入')
集合（Set）
去重，关系运算。无序，不可变（可hash）类型，可以作为字典的key，主要是不同的集合直接做关系运算。
存储 | 移除除
sea={'seagull','lele'}
sea.add('dongdong')
print(sea)
sea.pop() #任意删除
print(sea)
sea.remove('lele') #指定删除
print(sea)
in 和 not in
sea={'seagull','lele',18,'eat'}
if 'lele' in sea:
print('ok')
if 'dong' not in sea:
print('ok')
| 合集（union）
>>> a={1,2,4,5,10}
>>> b={3,4,7,8,10}
>>> print(a|b)
{1, 2, 3, 4, 5, 7, 8, 10}
>>> print(a.union(b))
{1, 2, 3, 4, 5, 7, 8, 10}
>>>
& 交集（intersection）
>>> a={1,2,4,5,10}
>>> b={3,4,7,8,10}
>>> print(a&b)
{10, 4}
>>> print(a.intersection(b))
{10, 4}
>>>
- 差集
>>> a={1,2,4,5,10}
>>> b={3,4,7,8,10}
>>> print(a-b)
{1, 2, 5}
>>> print(a.difference(b))
{1, 2, 5}
>>>
^ 对称差集
>>> a={1,2,4,5,10}
>>> b={3,4,7,8,10}
>>> print(a^b)
{1, 2, 3, 5, 7, 8}
>>> print(a.symmetric_difference(b))
{1, 2, 3, 5, 7, 8}
>>>
== 判断两个集合是否相等，返回布尔值
>>> a={1,2,4,5,10}
>>> b={3,4,7,8,10}
>>> print(a==b)
False>>>
>，>= ，<,<= 父集，子集（判断其中一个集合的元素是否均包含于另一个元素，返回布尔值）
>>> a={1,2,3,4,5}
>>> b={4,5}
>>> print(a>b)
True
>>> print(a>=b)
True
>>> print(a.issuperset(b))#a是否包含于b
True
>>>
>>> print(a<b)
False
>>> print(a<=b)
False
>>> print(a.issubset(b))
False
>>>
小练习：
# 一.关系运算 # 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'} linuxs={'wupeiqi','oldboy','gangdan'} # 1. 求出即报名python又报名linux课程的学员名字集合 print(pythons&linuxs) print(pythons.intersection(linuxs)) # 2. 求出所有报名的学生名字集合 print(pythons|linuxs) print(pythons.union(linuxs)) # 3. 求出只报名python课程的学员名字 print(pythons-linuxs) print(pythons.difference(linuxs)) # 4. 求出没有同时这两门课程的学员名字集合 print(pythons^linuxs) print(pythons.symmetric_difference(linuxs))
# 二.去重 # # 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序 l=['a','b',1,'a','a'] print(set(l)) # 2.在上题的基础上，保存列表原来的顺序 l=['a','b',1,'a','a'] sea=[] for list in l: if list not in sea: sea.append(list) print(sea) #或者 l=['a','b',1,'a','a'] sea=[] sea1=set() for list in l: if list not in sea: sea1.add(list) sea.append(list) print(sea) # 3.去除文件中重复的行，肯定要保持文件内容的顺序不变 import os with open('sea.txt','r',encoding='utf-8') as read_f,\ open('.sea.txt.swap','w',encoding='utf-8') as write_f: s=set() for line in read_f: if line not in s: s.add(line) write_f.write(line) os.remove('sea.txt') os.rename('.sea.txt.swap','sea.txt') # 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序 l=[ {'name':'egon','age':18,'sex':'male'}, {'name':'alex','age':73,'sex':'male'}, {'name':'egon','age':20,'sex':'female'}, {'name':'egon','age':18,'sex':'male'}, {'name':'egon','age':18,'sex':'male'}, ] sea=[] for list in l: if list not in sea: sea.append(list) print(sea) #或者 s=set() l1=[] for item in l: val=(item['name'],item['age'],item['sex']) if val not in s: s.add(val) l1.append(item) print(l1)
字典（Dict）
存储多个值，存在key值和value值，可变（不可hash）类型，需要注意的是，字典的key值是不可变的。
存/取
sea={} sea['name']='seagull' print(sea) print(sea['name'])
删除
>>> sea={'name':'seagull','age':18,'hobby':'eat'}
>>> sea.pop('name')
'seagull'
>>> print(sea)
{'age': 18, 'hobby': 'eat'}
>>>
长度
>>> sea={'name':'seagull','age':18,'hobby':'eat'}
>>> print(len(sea))
3
>>>
循环
sea={'name':'seagull','age':18,'hobby':'eat'}
for key in sea:
print(key)
for values in sea.values():
print(values)
for item in sea.items():
print(item)
小练习
# 1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。（2分） # # 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值} sea1=[11,22,33,44,55,66,77,88,99,90] sea2={'key1':[],'key2':[]} for list in sea1: if list > 66: sea2['key1'].append(list) elif list < 66: sea2['key2'].append(list) else: continue print(sea2)
# 2 统计s='hello alex alex say hello sb sb'中每个单词的个数 # # 结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2} s='hello alex alex say hello sb sb' sea={} for dic in s.split(): if dic in sea: sea[dic]+=1 else: sea[dic]=1 print(sea)
布尔（bool）
布尔型只有两个值，True或者False
你能够将Ture和False看作是预定义的设置为整数1和整数0的变量
>>> True +4 5 >>> a=True >>> a True >>> True == 1 True >>> False == 0 True >>>
Python文件处理
python中对文件、文件夹（文件操作函数）的操作需要涉及到os模块和shutil模块。
得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()
返回指定目录下的所有文件和目录名:os.listdir()
函数用来删除一个文件:os.remove()
删除多个目录：os.removedirs（r“c：\python”）
检验给出的路径是否是一个文件：os.path.isfile()
检验给出的路径是否是一个目录：os.path.isdir()
判断是否是绝对路径：os.path.isabs()
检验给出的路径是否真地存:os.path.exists()
返回一个路径的目录名和文件名:os.path.split() eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt')
分离扩展名：os.path.splitext()
获取路径名：os.path.dirname()
获取文件名：os.path.basename()
运行shell命令: os.system()
读取和设置环境变量:os.getenv() 与os.putenv()
给出当前平台使用的行终止符:os.linesep Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'
指示你正在使用的平台：os.name 对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'
重命名：os.rename（old， new）
创建多级目录：os.makedirs（r“c：\python\test”）
创建单个目录：os.mkdir（“test”）
获取文件属性：os.stat（file）
修改文件权限与时间戳：os.chmod（file）
终止当前进程：os.exit（）
获取文件大小：os.path.getsize（filename）
文件操作
os.mknod("test.txt") 创建空文件
fp = open("test.txt",w) 直接打开一个文件，如果文件不存在则创建文件
关于open 模式：
w 以写方式打开，
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
fp.read([size]) #size为读取的长度，以byte为单位 fp.readline([size]) #读一行，如果定义了size，有可能返回的只是一行的一部分 fp.readlines([size]) #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。 fp.write(str) #把str写到文件中，write()并不会在str后加上一个换行符 fp.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。 fp.close() #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。 如果一个文件在关闭后还对其进行操作会产生ValueError fp.flush() #把缓冲区的内容写入硬盘 fp.fileno() #返回一个长整型的”文件标签“ fp.isatty() #文件是否是一个终端设备文件（unix系统中的） fp.tell() #返回文件操作标记的当前位置，以文件的开头为原点 fp.next() #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。 fp.seek(offset[,whence]) #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。 fp.truncate([size]) #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。
目录操作
os.mkdir("file") 创建目录 复制文件： shutil.copyfile("oldfile","newfile") oldfile和newfile都只能是文件 shutil.copy("oldfile","newfile") oldfile只能是文件夹，newfile可以是文件，也可以是目标目录 复制文件夹： shutil.copytree("olddir","newdir") olddir和newdir都只能是目录，且newdir必须不存在 重命名文件（目录） os.rename("oldname","newname") 文件或目录都是使用这条命令 移动文件（目录） shutil.move("oldpos","newpos") 删除文件 os.remove("file") 删除目录 os.rmdir("dir")只能删除空目录 shutil.rmtree("dir") 空目录、有内容的目录都可以删 转换目录 os.chdir("path") 换路径
实例小练习
# 文件a.txt内容：每一行内容分别为商品名字，价钱，个数，求出本次购物花费的总钱数 # apple 10 3 # tesla 100000 1 # mac 3000 2 # lenovo 30000 3 # chicken 10 3 import fileinput count=0 file=fileinput.input('sea.txt') print('本次购买的商品信息：') for content in file: print(content,end="") content=list(content.split()) count=int(content[1]) * int(content[2])+count price=count print('\n商品总额是：{}'.format(price))
# 修改文件内容，把文件中的alex都替换成SB # i am seagull, # seagull is a looker. # and alex is a killer. with open('sea.txt','r') as r: lines=r.readlines() #按行读取文件 with open('sea.txt','w') as w: for l in lines: w.write(l.replace('alex','sb'))
忘羡一曲远，曲终人不散！问灵十三载，等一不归人！！！！
浙公网安备 33010602011771号