python基础之基本数据类型
数据类型的分类
数字、字符串、列表、元组、字典、集合
1.1、数字int型,主要是用来计算的。
1.1.1、布尔值型bool
真 1 True
假 0 False
2.1、字符串str
2.1.1、字符串的索引与切片
索引即下标,就是字符串组成的元素从第一个开始,初始索引为0。
a = 'ABCD' print(a[0]) ===> A print(a[1]) ===> B print(a[2]) ===> C print(a[3]) ===> D
切片就是通过索引(索引:索引:步长)截取字符串的一段,形成新的字符串(原则是顾头不顾腚)。
a = 'ABCDEF' print(a[0:2]) ===> AB print(a[2:4]) ===> CD print(a[0:]) ===> ABCDEF #默认到最后 print(a[0:-1]) ===> ABCDEF #-1就是最后一个 print(a[0:5:2]) ===> ACE #步长2 print(a[5:0:-2])===> FDB # 反向加步长
2.1.2 字符串的常用方法。
# capitalize / swapcase / title name = 'sunShine' msg = 'hello world' print(name.capitalize()) # 首字母大写,其它小写 Sunshine print(name.swapcase()) #大小写反转 SUNHINE print(msg.title()) # 每个单词首字母大写 Hello World #内同居中,总长度,空白处填充 res1 = name.center(20,'*') print(res1) # ******sunhine******* # 字符串中的元素出现的个数 res2 = name.count("n",0,7) # 在0到7个字符间出现n的次数 print(res2) # 2 a2 = "hqw\t" res3 = a2.expandtabs() # 默认将一个tab键编程8个空格,如果tab前面的字符长度不足8位,则补全8个, # 如果超过8个但是不足16个,则补全至16位,以此类推。 print(len(res3)) # 8 # startswith / endswith print(name.startswith('S')) # 判断name是否以S为开头,返回布尔值 #False print(name.endswith('e')) # 判断name是否以e为结尾,返回布尔值 # True print(name,name.endswith('hi',4,6)) print(name,name.startswith('Sh',3,6)) # find / index res4 = name.find('un',1,6) # 在索引1,6之间匹配,不写默认是全部匹配 print(res4) # 匹配结果则为1, 不匹配结果为 -1 res5 = name.index('i',3,7) print(res5) # 返回找到的元素的索引,找不到则报错。ValueError: substring not found # 5 # split / rsplit 以某个内容分隔,最终形成一个列表,此列表中不含有这个分割的元素 res6 = 'title,Title,test' print(res6.split('t')) #以t为分割,['', 'i', 'le,Ti', 'le,', 'es', ''] print(res6.rsplit('t',1)) # 按由右向左的顺序,只将第一个匹配到的分割['title,Title,tes', ''] # format 格式化输出 print('{} {} {}'.format('sunshine',28,'male')) #sunshine 28 male print('{1} {0} {1}'.format('sunshine',28)) #28 sunshine 28 print('{name} {age} {sex}'.format(name='sunshine',age=28,sex='male')) #sunshine 28 male # strip 一般用来去空 name='*sunshine**' print(name.strip('*')) #sunshine 去除所有的* print(name.lstrip('*')) #sunshine** 去除左边的* print(name.rstrip('*')) #*sunshine 去除右边的* # replace 将匹配的元素替换为新的元素 name = 'sunshine say :i am a good boy!' print(name.replace('sunshine','SS')) # is name = 'sunshine123' print(name.isalnum()) # 判断字符串是否由字母或者数字组成,返回布尔值 True print(name.isalpha()) # 判断字符串是否由纯字母组成,返回布尔值 False print(name.isdigit()) # 判断字符串是否由纯数字组成,返回布尔值 False
string.capitalize() #把字符串的第一个字符大写 # string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 # string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 # string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式解码 string,如果出错默认报一个 ValueError 的 异 常 , 除 非 errors 指 定 的 是 'ignore' 或 者'replace' # string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式编码 string,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace' # string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False. # string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8。 # string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中,如果 beg 和 end 指定范围,则检查是否包含在指定范围内,如果是返回开始的索引值,否则返回-1 # string.index(str, beg=0, end=len(string)) 跟find()方法一样,只不过如果str不在 string中会报一个异常. # string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False # string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False # string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False. # string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False. # string.islower() 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False # string.isnumeric() 如果 string 中只包含数字字符,则返回 True,否则返回 False # string.isspace() 如果 string 中只包含空格,则返回 True,否则返回 False. # string.istitle() 如果 string 是标题化的(见 title())则返回 True,否则返回 False # string.isupper() 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False # string.join(seq) 以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 # string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 # string.lower() 转换 string 中所有大写字符为小写. # string.lstrip() 截掉 string 左边的空格 # string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。 # max(str) 返回字符串 str 中最大的字母。 # min(str) 返回字符串 str 中最小的字母。 # string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. # string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定,则替换不超过 num 次. # string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数,不过是从右边开始查找. # string.rindex( str, beg=0,end=len(string)) 类似于 index(),不过是从右边开始. # string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 # string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找. # string.rstrip() 删除 string 字符串末尾的空格. # string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string,如果 num有指定值,则仅分隔 num 个子字符串 # string.splitlines(num=string.count('\n')) 按照行分隔,返回一个包含各行作为元素的列表,如果 num 指定则仅切片 num 个行. # string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查. # string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() # string.swapcase() 翻转 string 中的大小写 # string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle()) # string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 # string.upper() 转换 string 中的小写字母为大写
3.1 元组 tupe
元组也称为只读列表,数据只可以被查询,不能被修改。字符串的切片操作同样适用于列表。列表用()标示,黎明的元素用逗号隔开。如(1,2,3)
4.1 列表 list
列表是python的基础数据类型之一,是用[]括起来,每个元素以逗号隔开,里面可以存放各种数据类型。如:
li = ['sunshine',18,{'hobby':'eat'},[1,2,3]]
列表还可以储存大量数据,32位python的限制是536870912个元素,64位python的限制是1152921504606846975 个元素。
列表是有序的,有索引值,可以切片,方便取值。
4.1.1 增
# insert / append / extend li = [1,'a','b',2,3,'a'] li.insert(0,55) # 按索引增加个55的值 #[55, 1, 'a', 'b', 2, 3, 'a'] li.append('c')# 增加到最后 [55, 1, 'a', 'b', 2, 3, 'a', 'c'] li.append([1,2,3])#[55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3]] li.extend(['a,b,c']) # 迭代的去增加元素 [55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3], 'a,b,c'] li.extend(['a,b','ccc']) # [55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3], 'a,b,c', 'a,b', 'ccc'] li.extend('aaa') #[55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3], 'a,b,c', 'a,b', 'ccc', 'a', 'a', 'a'] li.extend('b,b')#[55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3], 'a,b,c', 'a,b', 'ccc', 'a', 'a', 'a', 'b', ',', 'b'] print(li)
4.1.2 删
li = [1,'a','b',2,3,'a'] li.pop(1) # 按索引位置去删除 print(li) #[1, 'b', 2, 3, 'a'] del li[1:3] # 按照位置去删除 print(li) #[1, 3, 'a'] li.remove('a') # 按照元素去删除 print(li) # [1, 3] li.clear() #清空列表 print(li) # []
4.1.3 改
li = [1,'a','b',2,3,'a'] li[1]='ccc' print(li) #[1, 'ccc', 'b', 2, 3, 'a'] li[4:6] = [5,7] print(li) #[1, 'ccc', 'b', 2, 5, 7]
4.1.4 查
通过切片的方式或者循环的方式去查。
4.1.5 其它操作
count (数) 统计某个元素在列表中出现的次数。
a = ['s','u','n','s','h','i','n','e'] print(a.count('s')) # 出现了2次
index 方法 用于从列表中找出某个值第一个匹配项的索引位置
a = ['s','u','n','s','h','i','n','e'] print(a.index('n')) # 第一个出现n的索引位置为 2
sort 在原位置对列表进行排序
a = ['s','u','n','s','h','i','n','e'] print(a.sort()) # 输出为 None a.sort() # 没有返回值 print(a) # ['e', 'h', 'i', 'n', 'n', 's', 's', 'u']
reverse 将列表中的元素反向存放
a = ['s','u','n','s','h','i','n','e'] # print(a.reverse()) # 输出为 None a.reverse() # 没有返回值 print(a) # ['e', 'n', 'i', 'h', 's', 'n', 'u', 's']
5.1 字典 dict
字典是Python中唯一的映射类型,采用键值对(key-->value)的形式存储数据。Python 对key进行哈希函数运算,根据运算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。可哈希表示kye必须是不可变类型,如:数组、字符串、元组。
字典是除列表之外最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象结合。两者的区别在于:字典是通过key来取值的,而不是通过偏移存取。
5.1.1 增
dic = {'name':'sunshine','age':28,'sex':'male'} dic['li'] = ['a','b'] print(dic) # {'name': 'sunshine', 'age': 28, 'sex': 'male', 'li': ['a', 'b']} # setdefault在字典中增加键值对,如果只有键那对应的值就是none,但是如果原字典中存在设置的键值对,则不会发生变更 #{'name': 'sunshine', 'age': 28, 'sex': 'male', 'li': ['a', 'b'], 'hobby': ['study', 'listen', 'eat']} dic.setdefault('hobby',['study','sleep','eat']) # 未发生变化 #{'name': 'sunshine', 'age': 28, 'sex': 'male', 'li': ['a', 'b'], 'hobby': ['study', 'listen', 'eat']} print(dic)
5.1.2 删
dic_pop1 = dic.pop('age') # pop 根据key删除键值对,并返回相应的值,如果没有key则返回默认值 print(dic_pop1) # 返回28 print(dic) # 返回{'name': 'sunshine', 'sex': 'male', 'li': ['a', 'b', 'c'], 'hobby': ['study', 'listen', 'eat']} dic_pop2 = dic.popitem() # 随机删除字典中的某个键值对,将删除的键值以元组的方式返回。 print(dic_pop2) # ('hobby', ['study', 'listen', 'eat']) print(dic) # {'name': 'sunshine', 'sex': 'male', 'li': ['a', 'b', 'c']} dic_clear = dic.clear() # 清空字典 print(dic_clear,dic) # None {}
5.1.3 改
dic1 = {'name':'sunshine','age':28,'sex':'male'} dic2 = {'name':'SS','age':18,'hobby':'eat'} dic2.update(dic1) # 将dic1所有的键值对覆盖添加到dic2中 print(dic2) #{'name': 'sunshine', 'age': 28, 'hobby': 'eat', 'sex': 'male'}
5.1.4 查
value1 = dic1['name'] # 没有相应的key则返回空 print(value1) # sunshine value2 = dic1.get('a','默认返回值') #没 相应的key则返回设定的返回值 print(value2) #默认返回值
5.1.5 其它
dic = {'name':'sunshine','age':28,'sex':'male'} item = dic.items() # dict_items类型,可迭代的 print(item,type(item)) #dict_items([('name', 'sunshine'), ('age', 28), ('sex', 'male')]) <class 'dict_items'> keys = dic.keys() # print(keys,type(keys)) #dict_keys(['name', 'age', 'sex']) <class 'dict_keys'> values = dic.values() # print(values,type(values)) #dict_values(['sunshine', 28, 'male']) <class 'dict_values'>
5.1.6 字典的循环
dic = {'name':'sunshine','age':28,'sex':'male'} for k in dic: print(k,end=" ") # name age sex for item in dic.items(): print(item,end=" ") #('name', 'sunshine') ('age', 28) ('sex', 'male') for k,v in dic.items(): print(k,v,end=" ") # name sunshine age 28 sex male
6.1 其它 range / enumerate / range
6.1.1 for 循环:用户按照顺序循环可迭代对象的内容。
msg = '我 love Python' for item in msg: print(item) # 每个字符是一个独立的个体,包含空格。 li = ['我','love','python'] for i in li: print(i) # 分为三个独立的单词 dic = {'name':'sunshine','age':28,'sex':'male'} for k,v in dic.items(): print(k,v) #每对键值对分别对应一个k,v
6.1.2 enumerate 枚举,对于一个可迭代的对象(iterable)/ 可遍历的对象(list,str等),enumerate将其组成一个索引序列,利用它可以同时获得索引和值
li = ['sunshine','爱','Python'] for i in enumerate(li): # 起始位置默认为0,可变更 print(i) #(0, 'sunshine') (1, '爱') (2, 'Python') for index,name in enumerate(li,1): print(index,name) #1 sunshine 2 爱 3 Python for index,name in enumerate(li,10): print(index,name) #10 sunshine 11 爱 12 Python
6.1.3 range 指定范围,生成指定数字
for i in range(1,5): print(i) # 1 2 3 4 for i in range(1,5,2): #指定步长 print(i) # 1 3 for i in range(5,1,-2): #指定反向步长 print(i) #5 3
7.1 集合
集合是无序的,不重复的数据集合,它里面的元素是可哈希的(不可变类型),但是集合本身是不可哈希的。主要作用是:
1、去重 ---> 把一个列表变成集合,就自动去重了。
2、关系测试 --> 测试两组数据之间的交集、差集、并集等关系。
7.1.1 创建集合
set1 = set({1,2,'sunshine'}) set2 = {1,2,'sunshine'} print(set1,type(set1)) # {1, 2, 'sunshine'} <class 'set'> print(set2,type(set2)) # {1, 2, 'sunshine'} <class 'set'>
7.1.2 增
set1 = {'sunshine','age',18} set1.add('hobby') print(set1) # {18, 'age', 'sunshine', 'hobby'} 集合是无序的 set1.update('A') print(set1) # {'A', 'sunshine', 18, 'hobby', 'age'} set1.update('BC') print(set1) # {'C', 'A', 'sunshine', 18, 'B', 'hobby', 'age'} set1.update([1,2,3]) print(set1) # {1, 2, 3, 'C', 'A', 'sunshine', 18, 'B', 'hobby', 'age'} # 复制集合 num1 = {1,2,3} num2 = num1.copy() print(num2) # {1, 2, 3}
7.1.3 删
set1 = {'sunshine','age',18} set1.remove('sunshine') # 删除一个元素 print(set1) # {'age', 18} set1.pop() # 随机删除一个元素 print(set1) # {'age'} set1.clear() # 清空集合 print(set1) # set() del set1 # 删除集合 print(set1) # 报错 NameError: name 'set1' is not defined # discard() 删除集合中指定的元素,删除不存在的则不操作 num = {1,2,3} num.discard(4) print(num) # {1, 2} num.discard(3) print(num) # {1, 2, 3}
7.1.4 其它操作
set1 = {1,2,3} set2 = {2,3,4}
交集 (& 或 intersection)
print(set1 & set2) # {2, 3} print(set1.intersection(set2)) #{2, 3} # intersection_update 交集更新操作 dreamers = {'ljl','wc','xy','zb','lsy'} girls = {'mmf','lsy','syj'} dreamers.intersection_update(girls) # 将集合dreamers与集合girls的交集赋值给dreamers print(dreamers) # {'lsy'}
并集 (| 或 union)
print(set1 | set2) # {1, 2, 3, 4} print(set2.union(set1)) # {1, 2, 3, 4}
差集 (- 或 difference)
print(set1 - set2) # {1} print(set1.difference(set2)) # {1} # difference_update 差集更新操作。 dreamers = {'ljl','wc','xy','zb','lsy'} girls = {'mmf','lsy','syj'} dreamers.difference_update(girls)# dreamers去除跟girls相同的元素 print(dreamers) #{'zb', 'ljl', 'xy', 'wc'}
反交集 (^ 或 symmetric_difference)
print(set1 ^ set2) # {1, 4} print(set1.symmetric_difference(set2)) # {1, 4}
子集与超集 (issubset / issuperset)
set1 = {1,2,3} set2 = {1,2,3,4,5} print(set1 < set2) # True print(set1.issubset(set2)) # True 说明set1 是 set2 的子集 print(set2 > set1) #True print(set2.issuperset(set1)) #True 说明set2 是 set1 的超集 # isdisjoint() # 检测2个集合是否不存在交集,存在交集则返回False res = set2.isdisjoint(set1) print(res) # False #symmetric_difference() 对称差集 set1 = {1,2,3} set2 = {2,3,4} res = set1.symmetric_difference(set2) print(res) # {1, 4} #symmetric_difference_update() 对称更新差集 set1.symmetric_difference_update(set2) print(set1) # {1, 4}
forzenset 不可变集合,让集合变成不可变类型
a = frozenset('sunshine') print(a,type(a)) # frozenset({'e', 's', 'n', 'i', 'u', 'h'}) <class 'frozenset'>
集合的一些应用
# 集合推导式 # 基本的集合推导式 var = {'zhangsan','lisi','wangwu'} res = {'*'+i+'*' for i in var} print(res) # {'*zhangsan*', '*lisi*', '*wangwu*'} # 带有判断条件的集合推导式 res = {i for i in var if i != 'zhangsan'} print(res) # {'lisi', 'wangwu'} # 多循环集合推导式 color = {'red','blue','yellow'} size = {11,22,33} res = {c + str(s) for c in color for s in size} print(res) # {'blue22', 'yellow11', 'blue33', 'red11', 'yellow33', 'blue11', 'red22', 'yellow22', 'red33'}
练习题:
购物车
功能要求:
要求用户输入总资产,例如:2000
显示商品列表,让用户根据序号选择商品,加入购物车购买,如果商品总额大于
总资产,提示账户余额不足,否则,购买成功
goods = [
{"name":"电脑","price":1999},
{"name":"鼠标","price":10},
{"name":"游艇","price":20},
{"name":"美女","price":998}
]
goods = [ {"name":"电脑","price":1999}, {"name":"鼠标","price":10}, {"name":"游艇","price":20}, {"name":"美女","price":998} ] while True: money = input("请输入你用于消费的预算:").strip() if not money.isdigit():continue money = int(money) break flag = True index_list = [] shop_list = [] def format_shop_list(): for index,v in enumerate(goods): print('+',(len(str(index))+7)*'-','+',(len(v['name'])+9)*'-','+',12*'-','+') index_list.append(index) print("| 序号 : %s | 名称 : %s | 价格 : %s |" %(index,v['name'],str(v['price']).center(5))) print('+',(len(str(index))+7)*'-','+',(len(v['name'])+9) * '-','+',12*'-','+') return index_list def quit_shop(shop_list,money): flag = False if len(shop_list) > 0 : print("您购买的商品为%s,余额为%s,欢迎下次再来" % (shop_list, money)) else:print("欢迎下次光临") return flag while flag: format_shop_list() buy = input('请输入需要购买的商品的序号:').strip() if buy in ['q','Q','quit','QUIT','exit','EXIT']: flag = quit_shop(shop_list,money) continue if not len(buy):continue if not buy.isdigit():continue buy = int(buy) if buy in index_list: if money >= goods[buy]['price']: money -= goods[buy]['price'] shop_list.append(goods[buy]['name']) else: print("您余额不足,请选择购买其它商品或者离开!") continue else: print("选择有误,请输入需要购买的商品序号!") continue print("现在购买的商品有%s,余额为%s" %(shop_list,money)) while True: keep_on = input("是否继续购买:[Y/N]").strip() if keep_on == "Y" or keep_on == 'y': break elif keep_on == "N" or keep_on == 'n': flag = quit_shop(shop_list,money) break else: print("请按提示输入!") continue