初进python世界之数据类型

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

基本运算符

常用数据类型:

字符串(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	gull'
 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使用'
',Linux使用'
'而Mac使用'
'

指示你正在使用的平台:os.name       对于Windows,它是'nt',而对于Linux/Unix用户,它是'posix'

重命名:os.rename(old, new)

创建多级目录:os.makedirs(r“c:python	est”)

创建单个目录: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('
商品总额是:{}'.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'))
复制代码

忘羡一

【推广】 免费学中医,健康全家人
原文地址:https://www.cnblogs.com/karkash/p/11747276.html