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