初进python世界之数据类型

文章来源： https://www.cnblogs.com/seagullunix/articles/7297946.html

基本运算符

经常使用数据类型：

字符串（Str）

数字（Digit）

列表（List）

元组（Tuple）

集合（Set）

字典（Dict）

布尔（bool）

 Python文件处理

基本运算符

---

 

固然，在讲数据类型以前，先了解一下Python的基本运算符：

运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算和位运算。如下分别学习每一个运算符：

1、算数运算：

运算符	描述	实例
+	普通的加法运算	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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

2、比较运算

说明： 如下比较的是两个对象的值。

运算符	描述	实例
==	等于，比较两个对象是否相等,返回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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

3、赋值运算

 

运算符	描述	实例
=	简单的赋值运算符，元素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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

4、逻辑运算

 

运算符	描述	实例
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

 

 

 

 

 

 

 

 

 

5、成员运算

 

运算符	描述	实例
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

 

 

 

 

 

 

 

6、身份运算

 说明只列出两个比较经常使用的，身份运算比较的是对象的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

 

 

 

 

 

 

7、位运算

比较二进制位，例如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, }

View Code

 

集合（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'))

 

忘羡一