阅读目录
简介
1 什么是数据？
x=10，10是我们要存储的数据
2 为何数据要分不同的类型
数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示
3 数据类型
数字（整形，长整形，浮点型，复数）
字符串
列表
元组
字典
集合
4 如何学习
#一：基本使用
1 用途
2 定义方式
3 常用操作+内置的方法
#二：该类型总结
1 存一个值or存多个值
只能存一个值
可以存多个值，值都可以是什么类型
2 有序or无序
3 可变or不可变
！！！可变：值变，id不变。可变==不可hash
！！！不可变：值变，id就变。不可变==可hash
数字
整型与浮点型
#整型int 作用：年纪，等级，身份证号，qq号等整型数字相关 定义： age=10 #本质age=int(10) #浮点型float 作用：薪资，身高，体重，体质参数等浮点数相关 salary=3000.3 #本质salary=float(3000.3) #二进制，十进制，八进制，十六进制
其他数字类型（了解）
#长整形（了解） 在python2中（python3中没有长整形的概念）： >>> num=2L >>> type(num) <type 'long'> #复数（了解） >>> x=1-2j >>> x.real 1.0 >>> x.imag -2.0
字符串
#作用：名字，性别，国籍，地址等描述信息 #定义：在单引号\双引号\三引号内，由一串字符组成 name='egon' #优先掌握的操作： #1、按索引取值(正向取+反向取) ：只能取 #2、切片(顾头不顾尾，步长) #3、长度len #4、成员运算in和not in #5、移除空白strip #6、切分split #7、循环
需要掌握的操作
1 #strip 2 name='*egon**' 3 print(name.strip('*')) 4 print(name.lstrip('*')) 5 print(name.rstrip('*')) 6 7 #lower,upper 8 name='egon' 9 print(name.lower()) 10 print(name.upper()) 11 12 #startswith,endswith 13 name='alex_SB' 14 print(name.endswith('SB')) 15 print(name.startswith('alex')) 16 17 #format的三种玩法 18 res='{} {} {}'.format('egon',18,'male') 19 res='{1} {0} {1}'.format('egon',18,'male') 20 res='{name} {age} {sex}'.format(sex='male',name='egon',age=18) 21 22 #split 23 name='root:x:0:0::/root:/bin/bash' 24 print(name.split(':')) #默认分隔符为空格 25 name='C:/a/b/c/d.txt' #只想拿到顶级目录 26 print(name.split('/',1)) 27 28 name='a|b|c' 29 print(name.rsplit('|',1)) #从右开始切分 30 31 #join 32 tag=' ' 33 print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串 34 35 #replace 36 name='alex say :i have one tesla,my name is alex' 37 print(name.replace('alex','SB',1)) 38 39 #isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法 40 age=input('>>: ') 41 print(age.isdigit()) 42 43 示例
其他操作（了解即可）
#1、find,rfind,index,rindex,count #2、center,ljust,rjust,zfill #3、expandtabs #4、captalize,swapcase,title #5、is数字系列 #6、is其他
1 #find,rfind,index,rindex,count 2 name='egon say hello' 3 print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引 4 # print(name.index('e',2,4)) #同上,但是找不到会报错 5 print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有 6 7 #center,ljust,rjust,zfill 8 name='egon' 9 print(name.center(30,'-')) 10 print(name.ljust(30,'*')) 11 print(name.rjust(30,'*')) 12 print(name.zfill(50)) #用0填充 13 14 #expandtabs 15 name='egon\thello' 16 print(name) 17 print(name.expandtabs(1)) 18 19 #captalize,swapcase,title 20 print(name.capitalize()) #首字母大写 21 print(name.swapcase()) #大小写翻转 22 msg='egon say hi' 23 print(msg.title()) #每个单词的首字母大写 24 25 #is数字系列 26 #在python3中 27 num1=b'4' #bytes 28 num2=u'4' #unicode,python3中无需加u就是unicode 29 num3='四' #中文数字 30 num4='Ⅳ' #罗马数字 31 32 #isdigt:bytes,unicode 33 print(num1.isdigit()) #True 34 print(num2.isdigit()) #True 35 print(num3.isdigit()) #False 36 print(num4.isdigit()) #False 37 38 #isdecimal:uncicode 39 #bytes类型无isdecimal方法 40 print(num2.isdecimal()) #True 41 print(num3.isdecimal()) #False 42 print(num4.isdecimal()) #False 43 44 #isnumberic:unicode,中文数字,罗马数字 45 #bytes类型无isnumberic方法 46 print(num2.isnumeric()) #True 47 print(num3.isnumeric()) #True 48 print(num4.isnumeric()) #True 49 50 #三者不能判断浮点数 51 num5='4.3' 52 print(num5.isdigit()) 53 print(num5.isdecimal()) 54 print(num5.isnumeric()) 55 ''' 56 总结: 57 最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景 58 如果要判断中文数字或罗马数字,则需要用到isnumeric 59 ''' 60 61 #is其他 62 print('===>') 63 name='egon123' 64 print(name.isalnum()) #字符串由字母或数字组成 65 print(name.isalpha()) #字符串只由字母组成 66 67 print(name.isidentifier()) 68 print(name.islower()) 69 print(name.isupper()) 70 print(name.isspace()) 71 print(name.istitle()) 72 73 示例
练习
# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分） name = " aleX" # 1) 移除 name 变量对应的值两边的空格,并输出处理结果 # 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果 # 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果 # 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 # 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。 # 6) 将 name 变量对应的值变大写,并输出结果 # 7) 将 name 变量对应的值变小写,并输出结果 # 8) 请输出 name 变量对应的值的第 2 个字符? # 9) 请输出 name 变量对应的值的前 3 个字符? # 10) 请输出 name 变量对应的值的后 2 个字符? # 11) 请输出 name 变量对应的值中 “e” 所在索引位置? # 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
1 # 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分） 2 name = " aleX" 3 # 1) 移除 name 变量对应的值两边的空格,并输出处理结果 4 name = ' aleX' 5 a=name.strip() 6 print(a) 7 8 # 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果 9 name=' aleX' 10 if name.startswith(name): 11 print(name) 12 else: 13 print('no') 14 15 # 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果 16 name=' aleX' 17 if name.endswith(name): 18 print(name) 19 else: 20 print('no') 21 22 # 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 23 name=' aleX' 24 print(name.replace('l','p')) 25 26 # 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。 27 name=' aleX' 28 print(name.split('l')) 29 30 # 6) 将 name 变量对应的值变大写,并输出结果 31 name=' aleX' 32 print(name.upper()) 33 34 # 7) 将 name 变量对应的值变小写,并输出结果 35 name=' aleX' 36 print(name.lower()) 37 38 # 8) 请输出 name 变量对应的值的第 2 个字符? 39 name=' aleX' 40 print(name[1]) 41 42 # 9) 请输出 name 变量对应的值的前 3 个字符? 43 name=' aleX' 44 print(name[:3]) 45 46 # 10) 请输出 name 变量对应的值的后 2 个字符? 47 name=' aleX' 48 print(name[-2:]) 49 50 # 11) 请输出 name 变量对应的值中 “e” 所在索引位置? 51 name=' aleX' 52 print(name.index('e')) 53 54 # 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。 55 name=' aleX' 56 a=name[:-1] 57 print(a)
列表
#作用：多个装备，多个爱好，多门课程，多个女朋友等 #定义：[]内可以有多个任意类型的值，逗号分隔 my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...]) 或 l=list('abc') #优先掌握的操作： #1、按索引存取值(正向存取+反向存取)：即可存也可以取 #2、切片(顾头不顾尾，步长) #3、长度 #4、成员运算in和not in #5、追加 #6、删除 #7、循环
#ps:反向步长 l=[1,2,3,4,5,6] #正向步长 l[0:3:1] #[1, 2, 3] #反向步长 l[2::-1] #[3, 2, 1] #列表翻转 l[::-1] #[6, 5, 4, 3, 2, 1]
练习
1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量 2. 用列表模拟队列 3. 用列表模拟堆栈 4. 有如下列表，请按照年龄排序（涉及到匿名函数） l=[ {'name':'alex','age':84}, {'name':'oldboy','age':73}, {'name':'egon','age':18}, ] 答案： l.sort(key=lambda item:item['age']) print(l)
元组
#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读 #定义：与列表类型比，只不过[]换成() age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55)) #优先掌握的操作： #1、按索引取值(正向取+反向取)：只能取 #2、切片(顾头不顾尾，步长) #3、长度 #4、成员运算in和not in #5、循环
练习
#简单购物车,要求如下： 实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入 msg_dic={ 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, }
1 msg_dic={ 2 'apple':10, 3 'tesla':100000, 4 'mac':3000, 5 'lenovo':30000, 6 'chicken':10, 7 } 8 goods_l=[] 9 while True: 10 for key,item in msg_dic.items(): 11 print('name:{name} price:{price}'.format(price=item,name=key)) 12 choice=input('商品>>: ').strip() 13 if not choice or choice not in msg_dic:continue 14 count=input('购买个数>>: ').strip() 15 if not count.isdigit():continue 16 goods_l.append((choice,msg_dic[choice],count)) 17 18 print(goods_l)
字典
#作用：存多个值,key-value存取，取值速度快 #定义：key必须是不可变类型，value可以是任意类型 info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....}) 或 info=dict(name='egon',age=18,sex='male') 或 info=dict([['name','egon'],('age',18)]) 或 {}.fromkeys(('name','age','sex'),None) #优先掌握的操作： #1、按key存取值：可存可取 #2、长度len #3、成员运算in和not in #4、删除 #5、键keys()，值values()，键值对items() #6、循环
练习
1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
1 a={'k1':[],'k2':[]} 2 c=[11,22,33,44,55,66,77,88,99,90] 3 for i in c: 4 if i>66: 5 a['k1'].append(i) 6 else: 7 a['k2'].append(i) 8 print(a)
2 统计s='hello alex alex say hello sb sb'中每个单词的个数 结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
1 s='hello alex alex say hello sb sb' 2 3 l=s.split() 4 dic={} 5 for item in l: 6 if item in dic: 7 dic[item]+=1 8 else: 9 dic[item]=1 10 print(dic)
1 s='hello alex alex say hello sb sb' 2 dic={} 3 words=s.split() 4 print(words) 5 for word in words: #word='alex' 6 dic[word]=s.count(word) 7 print(dic) 8 9 10 #利用setdefault解决重复赋值 11 ''' 12 setdefault的功能 13 1：key存在，则不赋值，key不存在则设置默认值 14 2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值 15 d={} 16 print(d.setdefault('a',1)) #返回1 17 18 d={'a':2222} 19 print(d.setdefault('a',1)) #返回2222 20 ''' 21 s='hello alex alex say hello sb sb' 22 dic={} 23 words=s.split() 24 for word in words: #word='alex' 25 dic.setdefault(word,s.count(word)) 26 print(dic) 27 28 29 30 #利用集合，去掉重复，减少循环次数 31 s='hello alex alex say hello sb sb' 32 dic={} 33 words=s.split() 34 words_set=set(words) 35 for word in words_set: 36 dic[word]=s.count(word) 37 print(dic)
集合
#作用：去重，关系运算， #定义： 知识点回顾 可变类型是不可hash类型 不可变类型是可hash类型 #定义集合: 集合：可以包含多个元素，用逗号分割， 集合的元素遵循三个原则： 1：每个元素必须是不可变类型(可hash，可作为字典的key) 2:没有重复的元素 3：无序 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值 #优先掌握的操作： #1、长度len #2、成员运算in和not in #3、|合集 #4、&交集 #5、-差集 #6、^对称差集 #7、== #8、父集：>,>= #9、子集：<,<=
练习
一.关系运算 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'} linuxs={'wupeiqi','oldboy','gangdan'} 1. 求出即报名python又报名linux课程的学员名字集合 2. 求出所有报名的学生名字集合 3. 求出只报名python课程的学员名字 4. 求出没有同时这两门课程的学员名字集合
1 # 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 2 pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'} 3 linuxs={'wupeiqi','oldboy','gangdan'} 4 # 求出即报名python又报名linux课程的学员名字集合 5 print(pythons & linuxs) 6 # 求出所有报名的学生名字集合 7 print(pythons | linuxs) 8 # 求出只报名python课程的学员名字 9 print(pythons - linuxs) 10 # 求出没有同时这两门课程的学员名字集合 11 print(pythons ^ linuxs)
二.去重 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序 2.在上题的基础上，保存列表原来的顺序 3.去除文件中重复的行，肯定要保持文件内容的顺序不变 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'}, ]
1 #去重,无需保持原来的顺序 2 l=['a','b',1,'a','a'] 3 print(set(l)) 4 5 #去重,并保持原来的顺序 6 #方法一:不用集合 7 l=[1,'a','b',1,'a'] 8 9 l1=[] 10 for i in l: 11 if i not in l1: 12 l1.append(i) 13 print(l1) 14 #方法二:借助集合 15 l1=[] 16 s=set() 17 for i in l: 18 if i not in s: 19 s.add(i) 20 l1.append(i) 21 22 print(l1) 23 24 25 #同上方法二,去除文件中重复的行 26 import os 27 with open('db.txt','r',encoding='utf-8') as read_f,\ 28 open('.db.txt.swap','w',encoding='utf-8') as write_f: 29 s=set() 30 for line in read_f: 31 if line not in s: 32 s.add(line) 33 write_f.write(line) 34 os.remove('db.txt') 35 os.rename('.db.txt.swap','db.txt') 36 37 #列表中元素为可变类型时,去重,并且保持原来顺序 38 l=[ 39 {'name':'egon','age':18,'sex':'male'}, 40 {'name':'alex','age':73,'sex':'male'}, 41 {'name':'egon','age':20,'sex':'female'}, 42 {'name':'egon','age':18,'sex':'male'}, 43 {'name':'egon','age':18,'sex':'male'}, 44 ] 45 # print(set(l)) #报错:unhashable type: 'dict' 46 s=set() 47 l1=[] 48 for item in l: 49 val=(item['name'],item['age'],item['sex']) 50 if val not in s: 51 s.add(val) 52 l1.append(item) 53 54 print(l1) 55 56 57 58 59 60 61 #定义函数,既可以针对可以hash类型又可以针对不可hash类型 62 def func(items,key=None): 63 s=set() 64 for item in items: 65 val=item if key is None else key(item) 66 if val not in s: 67 s.add(val) 68 yield item 69 70 print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex'])))) 71 复制代码
数据类型总结
数字 字符串 集合：无序，即无序存索引相关信息 元组：有序，需要存索引相关信息，不可变 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改 字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数区分
| 标量／原子类型 | 数字，字符串 |
| 容器类型 | 列表，元组，字典 |
| 可变 | 列表，字典 |
| 不可变 | 数字，字符串，元组 |
运算符
#身份运算（is ，is not） is比较的是id，而双等号比较的是值 毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同 >>> x=1234567890 >>> y=1234567890 >>> x == y True >>> id(x),id(y) (3581040, 31550448) >>> x is y False