一、前言
1,什么是数据?
x = 20 # 20 是我们要存储的数据
2,为何数据要分不同的类型?
数据是用来表示状态的,不同的状态就应该用不同的类型的数据去表示。
3,数据类型:
1)数字(整型,长整型,浮点型,复数)
2)字符串
3)字节串:字符编码中有字节 bytes 类型
4)布尔型
5)列表
6)元组
7)字典
8)集合
4,按照以下几个点展开数据类型的学习
-------------------- 基本使用 -------------------- 1,用途 2,定义方式 3,常用操作 + 内置方法 -------------------- 类型总结 -------------------- 1,存一个值 or 存多个值 2,有序 or 无序 3,可变 or 不变 1)可变:值变,id 不变。 可变 = 不可hash 2)不可变:值变,id 就变。 不可变 = 可hash
二、数字
1,整型与浮点型
# 整型int 作用:年纪,等级,身份证号,qq号等整型数字相关 定义: age=10 # 本质age=int(10) # 浮点型float 作用:薪资,身高,体重,体质参数等浮点数相关 salary=3000.3 # 本质salary=float(3000.3) # 二进制,十进制,八进制,十六进制
2,其他数字类型(了解)
# 长整形(了解) 在python2中(python3中没有长整形的概念): >>> num=2L >>> type(num) <type 'long'> # 复数(了解,推荐视频:https://www.bilibili.com/video/av26786159) >>> x=1-2j >>> x.real 1.0 >>> x.imag -2.0
三、字符串
1,定义:
# 作用:名字,性别,国籍,地址等描述信息 # 定义:在单引号双引号三引号内,由一串字符组成 name='zixi' # 优先掌握的操作: # 1,按索引取值(正向取+反向取) :只能取 # 2,切片(顾头不顾尾,步长) # 3,长度len # 4,成员运算in和not in # 5,移除空白strip # 6,切分split # 7,循环
2,需要掌握的操作
# 1、strip,lstrip,rstrip # 2、lower,upper # 3、startswith,endswith # 4、format的三种玩法 # 5、split,rsplit # 6、join # 7、replace # 8、isdigit
# strip name = '*zixi**' print(name.strip('*')) # 去掉两边的* print(name.lstrip('*')) # 去掉左边的* print(name.rstrip('*')) # 去掉右边的* # lower,upper name = 'zixi' print(name.lower()) # 把字符串变成小写的 print(name.upper()) # 把字符串变成大写的 # startswith,endswith # 以什么开头结尾,返回布尔值 name = 'alex_SB' print(name.endswith('SB')) print(name.startswith('alex')) # format的三种玩法 res = '{} {} {}'.format('zixi',18,'male') # zixi 18 male res1 = '{1} {0} {1}'.format('zixi',18,'male') # 18 zixi 18 res2 = '{name} {age} {sex}'.format(sex='male',name='zixi',age=18) # zixi 18 male # split name = 'root:x:0:0::/root:/bin/bash' print(name.split(':')) # 默认分隔符为空格,['root', 'x', '0', '0', '', '/root', '/bin/bash'] name = 'C:/a/b/c/d.txt' # 只想拿到顶级目录 print(name.split('/',1)) # ['C:', 'a/b/c/d.txt'] name = 'a|b|c' print(name.rsplit('|',1)) # 从右开始切分,['a|b', 'c'] # join tag = ' ' print(tag.join(['zixi','say','hello','world'])) # 可迭代对象必须都是字符串,zixi say hello world #replace name = 'old_six say :i have one tesla,my name is old_six' print(name.replace('old_six','SB',1)) # SB say :i have one tesla,my name is old_six # isdigit:可以判断 bytes和 unicode类型,是最常用的用于于判断字符是否为"数字"的方法 age = input('>>: ') print(age.isdigit())
3,其他操作(了解)
# 1、find,rfind,index,rindex,count # 2、center,ljust,rjust,zfill # 3、expandtabs # 4、captalize,swapcase,title # 5、is数字系列 # 6、is其他
# find,rfind,index,rindex,count name = 'zixi say hello' print(name.find('o',1,3)) # 顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引 # print(name.index('e',2,4)) # 同上,但是找不到会报错 print(name.count('e',1,3)) # 顾头不顾尾,如果不指定范围则查找所有 # center,ljust,rjust,zfill name = 'zixi' print(name.center(30,'-')) # -------------zixi------------- print(name.ljust(30,'*')) # zixi************************** print(name.rjust(30,'*')) # **************************zixi print(name.zfill(50)) # 用0填充,0000000000000000000000000000000000000000000000zixi # expandtabs:把字符串中的 tab 符号(' ')转为空格,tab 符号(' ')默认的空格数是 8。 name = 'zixi hello' print(name) # zixi hello print(name.expandtabs(1)) # zixi hello # capitalize,swapcase,title print(name.capitalize()) # 首字母大写,Zixi hello print(name.swapcase()) # 大小写翻转,ZIXI HELLO msg = 'zixi say hi' print(msg.title()) # 每个单词的首字母大写,Zixi Say Hi # is数字系列 # 在python3中 num1 = b'4' # bytes num2 = u'4' # unicode,python3中无需加u就是unicode num3 = '四' # 中文数字 num4 = 'Ⅳ' # 罗马数字 # isdigit:bytes,unicode 判断是否是数字 print(num1.isdigit()) # True print(num2.isdigit()) # True print(num3.isdigit()) # False print(num4.isdigit()) # False # isdecimal:unicode,检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 # bytes类型无isdecimal方法 print(num2.isdecimal()) # True print(num3.isdecimal()) # False print(num4.isdecimal()) # False # isnumeric:unicode,检测字符串是否只由数字组成。这种方法是只针对unicode对象。 # bytes类型无isnumeric方法 print(num2.isnumeric()) # True print(num3.isnumeric()) # True print(num4.isnumeric()) # True # 三者不能判断浮点数 num5 = '4.3' print(num5.isdigit()) print(num5.isdecimal()) print(num5.isnumeric()) ''' 总结: 最常用的是 isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景 如果要判断中文数字或罗马数字,则需要用到isnumeric ''' # is其他 print('===>') name = 'zixi123' print(name.isalnum()) # 字符串由字母或数字组成,True print(name.isalpha()) # 字符串只由字母组成,False print(name.isidentifier()) # True,判断字符串是否是有效的 Python 标识符,即可用此方法来判断变量名是否合法。 print(name.islower()) # True,是小写么 print(name.isupper()) # False,是大写么 print(name.isspace()) # False,检测字符串是否只由空格组成。 print(name.istitle()) # False,检查每个单词是否以大写字母开头
4,练习
# 写代码,有如下变量,请按照要求实现每个功能 (共6分,每小题各0.5分) name = " zolinG" # 1) 移除 name 变量对应的值两边的空格,并输出处理结果 # 2) 判断 name 变量对应的值是否以 "zo" 开头,并输出结果 # 3) 判断 name 变量对应的值是否以 "G" 结尾,并输出结果 # 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 # 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。 # 6) 将 name 变量对应的值变大写,并输出结果 # 7) 将 name 变量对应的值变小写,并输出结果 # 8) 请输出 name 变量对应的值的第 2 个字符? # 9) 请输出 name 变量对应的值的前 3 个字符? # 10) 请输出 name 变量对应的值的后 2 个字符? # 11) 请输出 name 变量对应的值中 “i” 所在索引位置? # 12) 获取子序列,去掉最后一个字符。如: oldsix 则获取 oldsi。
# 写代码,有如下变量,请按照要求实现每个功能 # name = " zolinG" # 1)移除 name 变量对应的值两边的空格,并输出处理结果 name = " zolinG" a = name.strip() print(a) # 2)判断 name 变量对应的值是否以 "zo" 开头,并输出结果 name = " zolinG" if name.startswith(name): print(name) else: print('no') # 3)判断 name 变量对应的值是否以 "G" 结尾,并输出结果 name = " zolinG" if name.endswith(name): print(name) else: print('no') # 4)将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 name = " zolinG" print(name.replace('l','p')) # zopinG # 5)将 name 变量对应的值根据 “l” 分割,并输出结果。 name = " zolinG" print(name.split('l')) # [' zo', 'inG'] # 6)将 name 变量对应的值变大写,并输出结果 name = " zolinG" print(name.upper()) # ZOLING # 7)将 name 变量对应的值变小写,并输出结果 name = " zolinG" print(name.lower()) # zoling # 8)请输出 name 变量对应的值的第 2 个字符? name = " zolinG" print(name[1]) # z # 9)请输出 name 变量对应的值的前 3 个字符? name = " zolinG" print(name[:3]) # zo # 10)请输出 name 变量对应的值的后 2 个字符? name = " zolinG" print(name[-2:]) # nG # 11)请输出 name 变量对应的值中 “i” 所在索引位置? name = " zolinG" print(name.index('i')) # 4 # 12)获取子序列,去掉最后一个字符。如: oldsix 则获取 oldsi。 name = " zolinG" a = name[:-1] print(a) # zolin
四、列表
1,定义,用法:
# 作用:多个装备,多个爱好,多门课程,多个女朋友等 # 定义:[]内可以有多个任意类型的值,逗号分隔 lis = ['zixi','zoling','zxc',4,5] # 本质lis = list([...]) # 也可以这么写 liss = list('abc') # 优先掌握的操作: # 1、按索引存取值(正向存取+反向存取):即可存也可以取 # 2、切片(顾头不顾尾,步长) # 3、长度 # 4、成员运算in和not in # 5、追加 # 6、删除 # 7、循环
# ps:反向步长 l = [1,2,3,4,5,6] # 正向步长 print(l[0:3:1]) # [1, 2, 3] # 反向步长 print(l[2::-1]) # [3, 2, 1] # 列表翻转 print(l[::-1]) # [6, 5, 4, 3, 2, 1]
2,练习:
""" 1. 有列表 data = ['zixi',49,[1900,3,18]], 分别取出列表中的名字,年龄,出生的年,月,日赋值给不同的变量 2. 用列表模拟队列 3. 用列表模拟堆栈 4. 有如下列表,请按照年龄排序(涉及到匿名函数) """ l = [ {'name':'zixi','age':20}, {'name':'zoling','age':25}, {'name':'xiaohua','age':18}, ]
l = [ {'name':'zixi','age':20}, {'name':'zoling','age':25}, {'name':'xiaohua','age':18}, ] # 答案: l.sort(key=lambda item:item['age']) print(l) # [{'name': 'xiaohua', 'age': 18}, {'name': 'zixi', 'age': 20}, {'name': 'zoling', 'age': 25}]
# sort() 函数用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数。 # 语法: list.sort(cmp=None, key=None, reverse=False) # 参数: """ cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。 key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。 reverse -- 排序规则,reverse = True 降序, reverse = False 升序(默认)。 """
五、元组
1,定义,用法:
# 作用:存多个值,对比列表来说,元组不可变(是可以当做字典的key的),主要是用来读 # 定义:与列表类型比,只不过[]换成() age = (11,22,33,44,55) # 本质 age = tuple((11,22,33,44,55)) # 优先掌握的操作: # 1、按索引取值(正向取+反向取):只能取 # 2、切片(顾头不顾尾,步长) # 3、长度 # 4、成员运算in和not in # 5、循环
2,练习:
# 简单购物车,要求如下: # 实现打印商品详细信息,用户输入商品名和购买个数,则将商品名,价格, # 购买个数加入购物列表,如果输入为空或其他非法输入则要求用户重新输入 msg_dic = { 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, }
msg_dic = { 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, } goods_l = [] while True: for key,item in msg_dic.items(): # 遍历字典,得到键值对的键和值 print('name:{name} price:{price}'.format(price=item,name=key)) choice = input('商品>>: ').strip() if not choice or choice not in msg_dic:continue count = input('购买个数>>: ').strip() if not count.isdigit():continue goods_l.append((choice,msg_dic[choice],count)) # 把买的商品追加到购物车中 print(goods_l)
六、字典
1,定义,用法:
# 作用:存多个值,key-value存取,取值速度快 # 定义:key必须是不可变类型,value可以是任意类型 info = {'name':'zixi','age':18,'sex':'male'} # 本质info = dict({....}) # 或 info = dict(name='zixi',age=18,sex='male') # 或 info = dict([['name','zixi'],('age',18)]) # 或 {}.fromkeys(('name','age','sex'),None) # 优先掌握的操作: # 1、按key存取值:可存可取 # 2、长度len # 3、成员运算in和not in # 4、删除 # 5、键keys(),值values(),键值对items() # 6、循环
2,练习1:
# 有如下值集合 [11,22,33,44,55,66,77,88,99,90...], # 将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中 # 即: {'k1': 大于66的所有值, 'k2': 小于66的所有值}
z = {'k1':[],'k2':[]} c = [11,22,33,44,55,66,77,88,99,90] for i in c: if i > 66: z['k1'].append(i) else: z['k2'].append(i) print(z) # {'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}
3,练习2:
# 统计 s = 'hello zixi zixi say hello db db' 中每个单词的个数 # 结果如:{'hello': 2, 'zixi': 2, 'say': 1, 'db': 2}
s = 'hello zixi zixi say hello db db' l = s.split() dic = {} for item in l: if item in dic: dic[item] += 1 else: dic[item] = 1 print(dic) # {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2}
3.1,其他做法(主要看setfault的用法):
# for 循环,循环添加 s = 'hello zixi zixi say hello db db' dic = {} words = s.split() print(words) for word in words: dic[word] = s.count(word) print(dic) """ ['hello', 'zixi', 'zixi', 'say', 'hello', 'db', 'db'] {'hello': 2} {'hello': 2, 'zixi': 2} {'hello': 2, 'zixi': 2} {'hello': 2, 'zixi': 2, 'say': 1} {'hello': 2, 'zixi': 2, 'say': 1} {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2} {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2} """
# 利用setdefault解决重复赋值 """ setdefault的功能 1:key存在,则不赋值,key不存在则设置默认值 2:key存在,返回的是key对应的已有的值,key不存在,返回的则是要设置的默认值 d = {} print(d.setdefault('a',1)) # 返回1 d = {'a':2222} print(d.setdefault('a',1)) # 返回2222 """ s = 'hello zixi zixi say hello db db' dic = {} words = s.split() for word in words: dic.setdefault(word,s.count(word)) print(dic) """ {'hello': 2} {'hello': 2, 'zixi': 2} {'hello': 2, 'zixi': 2} {'hello': 2, 'zixi': 2, 'say': 1} {'hello': 2, 'zixi': 2, 'say': 1} {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2} {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2} """
# 利用集合,去掉重复,减少循环次数 s = 'hello zixi zixi say hello db db' dic = {} words = s.split() words_set = set(words) for word in words_set: dic[word] = s.count(word) print(dic) """ {'hello': 2} {'hello': 2, 'db': 2} {'hello': 2, 'db': 2, 'zixi': 2} {'hello': 2, 'db': 2, 'zixi': 2, 'say': 1} """
七、集合
1,定义,用法:
""" 作用:去重,关系运算, 定义: 知识点回顾 可变类型是不可hash类型 不可变类型是可hash类型 定义集合: 集合:可以包含多个元素,用逗号分割, 集合的元素遵循三个原则: 1:每个元素必须是不可变类型(可hash,可作为字典的key) 2: 没有重复的元素 3:无序 注意集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值 优先掌握的操作: 1、长度len 2、成员运算in和not in 3、|合集 4、&交集 5、-差集 6、^对称差集 7、== 8、父集:>,>= 9、子集:<,<= """
2,练习1:
""" 关系运算: 有如下两个集合,pythons是报名python课程的学员名字集合,linuxs是报名linux课程的学员名字集合 pythons = {'托儿所','zixi','zoling','儿童劫','娃娃鱼','瑞萌萌'} linuxs = {'zixi','儿童劫','瑞萌萌'} 1. 求出即报名python又报名linux课程的学员名字集合 2. 求出所有报名的学生名字集合 3. 求出只报名python课程的学员名字 4. 求出没有同时这两门课程的学员名字集合 """
# 有如下两个集合,pythons是报名python课程的学员名字集合,linuxs是报名linux课程的学员名字集合 pythons = {'托儿所','zixi','zoling','儿童劫','娃娃鱼','瑞萌萌'} linuxs = {'zixi','儿童劫','瑞萌萌'} # 求出即报名python又报名linux课程的学员名字集合 print(pythons & linuxs) # 求出所有报名的学生名字集合 print(pythons | linuxs) # 求出只报名python课程的学员名字 print(pythons - linuxs) # 求出没有同时这两门课程的学员名字集合 print(pythons ^ linuxs) """ {'儿童劫', '瑞萌萌', 'zixi'} {'娃娃鱼', '瑞萌萌', '托儿所', 'zoling', '儿童劫', 'zixi'} {'托儿所', 'zoling', '娃娃鱼'} {'托儿所', 'zoling', '娃娃鱼'} """
3,练习2:
""" 去重: 1. 有列表l=['a','b',1,'a','a'],列表元素均为可hash类型,去重,得到新列表,且新列表无需保持列表原来的顺序 2.在上题的基础上,保存列表原来的顺序 3.去除文件中重复的行,肯定要保持文件内容的顺序不变 4.有如下列表,列表元素为不可hash类型,去重,得到新列表,且新列表一定要保持列表原来的顺序 """ l = [ {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zoling','age':20,'sex':'female'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, ]
# 去重,无需保持原来的顺序 l = ['a','b',1,'a','a'] print(set(l)) # {'a', 1, 'b'}
# 去重,并保持原来的顺序 # 方法一:不用集合 l = [1,'a','b',1,'a'] l1 = [] for i in l: if i not in l1: l1.append(i) print(l1) # [1, 'a', 'b']
# 方法二:借助集合 l = [1,'a','b',1,'a'] l1 = [] s = set() for i in l: if i not in s: s.add(i) l1.append(i) print(l1) # [1, 'a', 'b']
# 列表中元素为可变类型时,去重,并且保持原来顺序 l = [ {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zoling','age':20,'sex':'female'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, ] # print(set(l)) # 报错:unhashable type: 'dict' 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) # [{'name': 'zixi', 'age': 18, 'sex': 'male'}, {'name': 'zoling', 'age': 20, 'sex': 'female'}]
# 定义函数,既可以针对可以hash类型又可以针对不可hash类型 l = [ {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zoling','age':20,'sex':'female'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, ] def func(items,key=None): s = set() for item in items: val = item if key is None else key(item) if val not in s: s.add(val) yield item print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex'])))) # [{'name': 'zixi', 'age': 18, 'sex': 'male'}, {'name': 'zoling', 'age': 20, 'sex': 'female'}]
八、数据类型总结
1,按存储空间的占用分(从低到高)
# 数字 # 字符串 # 集合:无序,即无序存索引相关信息 # 元组:有序,需要存索引相关信息,不可变 # 列表:有序,需要存索引相关信息,可变,需要处理数据的增删改 # 字典:无序,需要存key与value映射的相关信息,可变,需要处理数据的增删改
2,按存值个数区分:
3,按可变不可变区分:
4,按访问顺序区分:
九、运算符
1,身份运算
#身份运算(is ,is not) is比较的是id,而双等号比较的是值 毫无疑问,id若相同则值肯定相同,而值相同id则不一定相同 >>> x=1234567890 >>> y=1234567890 >>> x == y True >>> id(x),id(y) (3581040, 31550448) >>> x is y False