python3 数据类型

#标准的数据类型
'''
python有6个标准的原生数据类型
1、数字(Number)
2、字符串（String）有序的
3、列表（List）有序的
4、元祖（Tuple）有序的
5、集合（Set）无序的，集合的好处是可以去重(去掉重复数据)
6、字典（Dictionary）无序的
序列的有字符串、列表、元祖、集合，都可以用索引，第一个代表0索引，第二个代表1索引
'''

print('*********************************************************')
print('*********************************************************')
# >>>1、数字类型>>分为整型（int）、浮点型（float）和复数（complex numbers）
# 数字类型可以执行运算，也称为算数运算符
zs = 1246 #整数(int)
fds = 12.54 #浮点数(float)
age = 23	#23默认是int整数，不属于字符串
message = "Happy " + str(age) + "rd Birthday!"	#当字符串里面出现整数和字符串的时候，就要使用str()函数将整数修改成字符串
#如果上面不添加str()函数，就会报错TypeError: must be str, not int  ，因为语法里面包含了两种数据类型int和str
print(message)
print(5 + 4) # 加法
print(5 - 4) # 减法
print(5 * 4) # 乘法
print(5 / 4) # 除法
print(5 // 4) # 整除(底板除)，取整除，不取小数点，不会四舍五入
print(5 % 4) # 取余(取模)
print(5 ** 4) # 乘方，例如 5**4 = 5*5*5*5
print('-'*50)

print('*********************************************************')
print('*********************************************************')
# >>>2、字符串(string)，用' '或者" "表示
a = '呵呵'
print(type(a))

# 字符串可以拼接
print("hello" + "文哥") # 输出hello文哥

# 多行输出字符串，可以用三引号输出，输出的结果也是会换行
a = '''
哈哈
111
呵呵
'''
print(a)

# 字符串格式化
print("%s hello! %s" % ("早上好","文哥")) #输出 早上好 hello！ 文哥
'''
格式符分很多种
%s      字符串
%f      浮点数，大写%F也是一样，%.2f就代表结果保留2个小数，会按照四舍五入法
%d      十进制整数，也就是数字
%c      单个字符(暂时不了解干嘛用)
%b      二进制整数(暂时不了解干嘛用)
%o      八进制整数(暂时不了解干嘛用)
%x      十六进制整数(暂时不了解干嘛用)
%e      指数(基底为e)(暂时不了解干嘛用)
%E      指数(基底为E)(暂时不了解干嘛用)
%g      指数(e)或浮点数 (根据显示长度)(暂时不了解干嘛用)
%G      指数(E)或浮点数 (根据显示长度)(暂时不了解干嘛用)
'''

# 转义字符
# python在使用 \ 这个特殊符号时，会产生转义，如果不想让反斜杠发生转义，可以在字符串面前添加一个字符 r ，表示原始字符串
print("a\nb") #输出的结果就会 a 换行在输出 b
a = "c:\\now"
print(a) # 输出 c:\now
# 如果字符串中出现很多需要用 \ 反斜杠的
print("c:\\nx\\na\\ss") # 输出 c:\xx\aa\ss
#但是使用太多反斜杠会眼花撩开，所以这里可以在字符串前加 r ，就可以表示该字符串不会发生转义
print(r"c:\na\nc\ns") # 这个适合在使用文件的时候使用
print('-'*50)

# 索引和切片，[头下标：尾下标：步长]
# 索引基本适用于所有有序的容器，索引都是从0开始算，0代表第一个值，1代表第二个值，注意：如果是倒数的话，那就是从1开始算
a = 'asdadq' # 字符串string
print(a[1]) #输出 s
a = ['q','w','e'] # 列表list
print(a[0]) # 输出 q
a = ('a','s','d') # 元祖tuple
print(a[2]) # 输出 d
a = '123456789'
print(a[1:5]) # 输出 2345
print(a[-1:-5:-1]) # 输出 9876
print(a[3:8:2]) # 输出 468
print(a[::2]) # 输出 13579
print(a[::3]) # 输出 147
print(a[:]) # 如果不设置开头和结尾数，那就自动打印所有数据
print(a[::-1]) # 这种写法可以将容器里面的值倒过来输出
print(len(a)) # 使用len函数可以查看容器的长度，这里输出 9
print("2" in a) # in方法可以判断该字符是否存在a变量里面，如果存在而返回True，返回结果是布尔类型
print("11" in a) # 不存在则返回False
print(max(a)) # 使用max函数查看最大值
print(min(a)) # 使用min函数查看最小值
a = [1,2,3]
print(sum(a)) # 使用sum函数可以将列表或者元祖里面的整数相加

# 字符串格式化
# python还支持另一种字符串格式化，语法：string.format()
print("{}，早上好，{}".format("哈喽","文哥")) # 就会输出 哈喽，早上好，文哥
print("{1}，你好，欢迎来到{0}".format("list","boss")) # 可以在{}里面添加位置符号，让指定的值添加到指定的位置上


print('*********************************************************')
print('*********************************************************')
# >>>3、列表(list)
# 列表是python最常用的数据类型，列表里的元素可以有任何数据类型，不需要相同
a = ["haha","hehe",123,456] # 列表里可以有字符串、整数等等
print(a) # 输出 ['haha', 'hehe', 123, 456]
a = [1,2,3,4,5,6]
print(a[1]) # 列表的索引也同样是由0开始算，这里输出 2
a[2] = 30 # 将a列表中的2下标替换成 30
print(a) # 输出 [1, 2, 30, 4, 5, 6]
a[1:3] = 300,400,500 # 将下标 1-3 的数据替换
print(a) # 输出 [1, 300, 400, 500, 4, 5, 6]
# 第一种删除列表中的元素方法
a[0:1] = [] #将列表中的 1 元素删除了
print(a) # 输出 [300, 400, 500, 4, 5, 6]
# 第二种删除列表中的元素方法
del a[2:4] # 将列表中的 500和4 元素删除了，删除了2和3下标的元素
print(a) # 输出 [300, 400, 5, 6]
#使用列表中的各个元素，插入到字符串里面
bicycles = ['trek', 'cannondale', 'redline', 'specialized']	#创建一个简单的列表
message = "My first bicycle was a " + bicycles[0].title() + "."	#在字符串中插入bicycles列表中的第一个元素，并使用title()函数将提取的元素开头字母改大写输出
print(message) # My first bicycle was a Trek.
print(a[::-1]) # 这样可以将列表的元素倒过来

#增删改查

#修改元素
motorcycles = ['honda', 'yamaha', 'suzuki']	#定义列表
print(motorcycles)
motorcycles[0] = 'ducati'	#修改列表中第一个元素，将原来的honda修改成ducati
print(motorcycles)	#修改后输出 ['ducati', 'yamaha', 'suzuki']

#添加元素，有两种方法
#1、append()函数，在列表末尾添加元素
motorcycles = ['honda', 'yamaha', 'suzuki']	#定义列表
motorcycles.append('haojue')	#使用append()函数可以将元素添加到列表末尾
print(motorcycles) # ['honda', 'yamaha', 'suzuki', 'haojue']

#也可以在空列表里面添加
kong = []	#创建空列表
#然后将元素添加进去
kong.append('xiaowen')
kong.append('xiaohua')
kong.append('xiaohong')
print(kong) # 输出 ['xiaowen', 'xiaohua', 'xiaohong']

#2、insert()函数，在列表中插入元素，也可以说在指定的位置插入元素，insert()函数括号中里面要写的参数是（索引位置，需要添加的元素）
motorcycles = ['honda', 'yamaha', 'suzuki']	#定义列表
motorcycles.insert(0, 'zixingche')	#这句语法的意思是使用insert()函数在第一个坐标位置添加元素zixingche
print(motorcycles) # 输出 ['zixingche','honda', 'yamaha', 'suzuki']

#从列表中删除元素
#1、使用 del 语句删除元素
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
del motorcycles[0]	#使用del语句删除motorcycles列表中的第一个元素，[]里面写索引
print(motorcycles) #['yamaha', 'suzuki']

#2、使用方法 pop() 删除元素,pop属于永久性在列表里删除
#方法 pop() 可删除列表末尾的元素，并让你能够接着使用它，可以把这个当成是娃娃机的抓手
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)	#输出原列表 ['honda', 'yamaha', 'suzuki']
popped_motorcycle = motorcycles.pop()	#使用pop()删除motorcycles列表末尾的元素
print(motorcycles)	#删除后的列表 ['honda', 'yamaha']
print(popped_motorcycle)	#将pop所删除的元素提取出来，可以二次使用 输出suzuki
print("The last motorcycle I owned was a " + popped_motorcycle.title() + ".")	#插入到字符串里面，并使用title()函数将提取的元素开头字母改大写输出
#其实pop()函数可以删除任何位置的元素，只需要在括号里面填写索引就可以了，不填写的话默认是末尾
popped_motorcycle = motorcycles.pop(1)	#删除列表中第二个元素
print(popped_motorcycle) #yamaha
#也可以将删除的元素提取出来，添加到另一个列表中
asd = []	#创建新列表
asd.append(popped_motorcycle.title())	#将append()函数中的括号填写参数，填写变量名popped_motorcycle，并使用title()函数将提取的元素开头字母改大写存储到新列表中
print(asd) #['Yamaha']

#3、根据值删除元素
#有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法 remove()函数，简称：删除指定名字的元素
motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles) # ['honda', 'yamaha', 'suzuki', 'ducati']
motorcycles.remove('suzuki')	#使用remove()函数删除指定的值
print(motorcycles) # ['honda', 'yamaha', 'ducati']
#可以将删除的值用来调用一下，插入字符串中
too_expensive = 'ducati'
motorcycles.remove(too_expensive)
print(motorcycles) # ['honda', 'yamaha']
print("\nA " + too_expensive.title() + " is too expensive for me.") #A Ducati is too expensive for me.
#方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。
a = ['adas','hajkd','add','adas','hajkd'] #list列表
print(a) #['adas','hajkd','add','adas','hajkd']
del a[1] #使用del删除指定索引的数据
print(a)
a.clear() #清除列表所有数据
print(a)

#组织列表
#使用方法 sort()函数 对列表进行永久性排序
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()	#将cars列表使用sort()函数按字母顺序永久的排序一下，这种写法不管你调用多少次，都是按排序后的顺序显示
print(cars) #['audi', 'bmw', 'subaru', 'toyota']
#如果想反顺序排序，可以在sort()函数括号里面，添加参数reverse=True就可以了，也是永久性的
cars.sort(reverse=True)
print(cars) #['toyota', 'subaru', 'bmw', 'audi']

#使用函数 sorted() 对列表进行临时排序reverse
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars) #['bmw', 'audi', 'toyota', 'subaru']
print(sorted(cars))	#使用sorted()函数对列表进行临时顺序排序，括号里面填写列表
#['audi', 'bmw', 'subaru', 'toyota']
print(cars) #['bmw', 'audi', 'toyota', 'subaru']
#如果想反顺序排序，可以在sorted()函数括号里面，添加参数reverse=True就可以了，也是临时性的
print(sorted(cars,reverse=True))	#sorted()函数括号里面可以添加两个参数
#['toyota', 'subaru', 'bmw', 'audi']
print(cars) #['bmw', 'audi', 'toyota', 'subaru']

#倒着打印原列表，属于永久性的
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars) #['bmw', 'audi', 'toyota', 'subaru']
cars.reverse()	#使用reverse()函数可以将原列表倒过来打印，注：这个不是排序，只是将原列表倒过来，这个也是属于永久性的
print(cars) #['subaru', 'toyota', 'audi', 'bmw']
#不过想要再恢复到原列表的话，可以再注明一次reverse()函数就可以了
cars.reverse()	#这样就可以返回原列表了
print(cars) #['subaru', 'toyota', 'audi', 'bmw']
#使用len()函数可以快速获取列表的长度，len()在做项目的时候很有用
print(len(cars))	#返回的是数字 4

# 嵌套列表
a = [[123,456],[741,852]]
print(a[0][0]) # 用切片访问，输出 123

# 列表转字典
ls = [('a',1),('b',2)]
print(ls) # [('a', 1), ('b', 2)]
# 使用dict函数转换成字典
print(dict(ls)) # {'a': 1, 'b': 2}


# 用队列实现斐波那契数列
count = 5  # 上限值
a, b = 1, 1
ls = []
for i in range(count):
    ls.append(a)
    a, b = b, a + b

print(ls)
'''
#上面代码推导过程如下
xx1 = 1
xx2 = 1
xx3 = xx1 + xx2 相当于 1+1=2
xx4 = xx2 + xx3 相当于 1+2=3
xx5 = xx3 + xx4 相当于 2+3=5
以此类推，根据最大值往下推
'''



print('*********************************************************')
print('*********************************************************')
# >>>4、元祖(tuple)
"""
元祖与列表类似，但是元祖的元素不能被修改，否则就报错
元祖常用的操作只有index和count
在实际开发中，能应用元祖的场景有：
 - 可以做成函数的参数或返回值	函数的 参数和返回值，一个函数可以接受任意多个参数，或者一次返回多个数据
 - 格式字符串		格式化字符串后面的()本质上就是一个元祖
 - 可以保护数据安全	让列表不可以被修改，以保护数据安全
"""
a = ('haha','hehe',1,312,'hehe') #元祖
print(a)
print(a[1]) #访问元祖中的1坐标元素
print(a.index('hehe')) #获取数据第一次出现的索引
print(a.count('hehe')) #count方法查看数据在列表中出现的次数

#元祖和列表之间的转换
a = ['aa','ss','dd']
w = tuple(a) #使用tuple将数据转换成元祖
print(type(w)) #使用type查看数据类型
print(w)
q = list(a) #使用list将数据转换成列表
print(type(q))
print(q)

#Python将不能修改的值称为不可变的，而不可变的列表被称为元组。不能增、删、改
#定义元组,元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。
dimensions = (200, 50)	#定义元祖
print(dimensions)
print(dimensions[0])	#遍历元祖的第一个元素
print(dimensions[1])	#遍历元祖的第二个元素
#dimensions[0] = 250	#可以尝试修改元祖中的值，但是修改不了，直接报错，元祖是不可被修改的

#如果确实想修改元祖的元素
#修改元组变量
dimensions = (400, 150)	#将元祖的变量名重新赋值，这样就可以修改了
print(dimensions)



print('*********************************************************')
print('*********************************************************')
# 5、集合(set)
# 集合是无序的，不包括重复元素的集，基本功能包括关系测试和删除重复元素
# 可以用花括号{}创建集合，注意：如果单单创建一个空集合，必须要用set()函数，否则就成了创建空字典了

# 删除重复元素
a = {'a','b','c','a','f','b'}
print(a) # 就会输出 {'a', 'b', 'c', 'f'}

#也可使用遍历
for i in a:
    print(i)

# 下面介绍几个set使用的几个方法
a = set('afwfweafdfdadsfad')
b = set('afsdvasdfwffadfsd')
# 删除重复
print(a);print(b)
# a - b方法，在a集合里面，但是不在b集合里面的字母
print(a - b)
# a | b方法，在a集合里面或者在b集合里面的字母（也可以简称是打印a和b集合里面的字母）
print(a | b)
# a & b方法，在a集合和b集中都有的字母
print(a & b)
# a ^ b方法，在a集合和b集合不同时存在的字母
print(a ^ b)



print('*********************************************************')
print('*********************************************************')
# 6、字典
# 在Python中，字典是一系列键 - 值对。每个键都与一个值相关联，你可以使用键来访问与之相关联的值。
# 与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。
# 在Python中，字典用放在花括号 {} 中的一系列键 - 值对表示
alien_0 = {'color': 'green'}  # 字符串 'color' 是一个键，与之相关联的值为 'green'
# 访问字典中的值
alien_0 = {'color': 'green'}
print(alien_0['color'])  # 返回alien_0字典中的键'color'相关联的值,也就是green
# 字典中可包含多个键值对
alien_0 = {'color': 'green', 'points': 5}
new_points = alien_0['points']  # 将alien_0字典中的键'color'相关联的值储存到new_points变量中
print("You just earned " + str(new_points) + " points!")  # 将new_points变量的值插入到语句中，使用str转换成字符串类型

# 添加键 — 值对
# 字典是一种动态结构，可随时在其中添加键 — 值对。要添加键 — 值对，可依次指定字典名、用方括号括起的键和相关联的值。
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
# 在字典末尾处添加键值对
alien_0['x_position'] = 0  # 在alien_0这个字典中新增了一个键 — 值对，其中的键为 'x_position' ，而值为 0
alien_0['y_position'] = 25
print(alien_0)

# 修改字典中的值
alien_0 = {'color': 'green', 'points': 5}
print("The alien is " + alien_0['color'] + ".")  # 将alien_0中的键color相关联的值插入到语句中打印出来
alien_0['color'] = 'yellow'  # 修改alien_0字典中的键color相关联的值，修改它的值为yellow
print("The alien is now " + alien_0['color'] + ".")
print(alien_0)

# 字典中的小例子
alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'}
print("Original x-position: " + str(alien_0['x_position']))
# alien_0['speed'] = 'fast'	#可修改键speed中的值
if alien_0['speed'] == 'slow':  # 当alien_0字典中的键speed的值等于slow，就执行缩进代码
    x_increment = 1  # 定义一个变量，赋值1
elif alien_0['speed'] == 'medium':  # #当alien_0字典中的键speed的值等于medium，就执行缩进代码
    x_increment = 2  # 定义一个变量，赋值2
else:  # 如果上面两个都不执行，那么就执行这里
    x_increment = 3  # 定义一个变量，赋值3
# 然后将alien_0字典中的键x_position的值加上if语句中条件成立的代码（变量名x_increment赋值的值），然后再储存回字典alien_0中的键x_position相关联的值
alien_0['x_position'] = alien_0['x_position'] + x_increment
print("New x-position: " + str(alien_0['x_position']))

# 删除键 — — 值对
# 对于字典中不再需要的信息，可使用del语句将相应的键—值对彻底删除。使用del语句时，必须指定字典名和要删除的键。
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']  # 使用del删除alien_0字典中的键points和它相关联的值
print(alien_0)

# 当字典过长的时候，可这样书写
zidian = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
}
print(zidian)
# 当print语句过长，也可以这样书写
print("Sarah's favorite language is " +
      zidian['jen'].title() +
      ".")

# 遍历字典
# 遍历所有的键 — — 值对
user_0 = {
    'username': 'efermi',
    'first': 'enrico',
    'last': 'fermi',
}
# 因为字典是由键--值对组成的，所以使用遍历的时候需要需用两个变量来储存键和值
# 字典的items方法作用：是可以将字典中的所有项，以列表方式返回，当你有两个变量的时候，不使用这个函数就会报错
for k, v in user_0.items():  # 建立两个变量，分别是k、v，遍历user_0字典，使用items()函数以列表的形式返回
    print(k + '-----' + v)  # k变量输出的代表键，v变量输出的代表相关联的值
    print('hello,ni hao a ' + k + ',ni de zhi shi ' + v)  # 将键和值分别插入语句当中

# 遍历字典中的所有键
# 如果不使用两个变量来储存遍历的话，就成了遍历字典中的键
for i in user_0:  # 或者for i in user_0.keys():	，keys()代表字典中的键
    print(i)

user_0 = {
    'username': 'efermi',
    'first': 'enrico',
    'last': 'fermi',
}
list = ['last', 'first']
for k in user_0:  # 遍历user_0字典中的键
    # print(k)
    if k in list:  # 将字典中的键遍历列表中的元素，当列表中的元素存在与字典中的键相同时，将其输出出来
        print(k)

# 按顺序遍历字典中的所有键
user_0 = {
    'username': 'efermi',
    'first': 'enrico',
    'last': 'fermi',
}
for k in sorted(user_0):  # 使用sorted函数将遍历的字典临时按字母顺序排列
    print(k)

# 遍历字典中的所有值，使用values()方法
user_0 = {
    'username': 'efermi',
    'first': 'enrico',
    'last': 'fermi',
}
for i in user_0.values():
    print(i)

# 使用set()方法可剔除字典中的重复项
favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
}
for language in set(favorite_languages.values()):  # 打印字典中的所有值，使用set方法可剔除字典中的重复值
    print(language.title())
# 这个项目输出的值是无序的，而且每次顺序都打乱了

# 嵌套
# 有时候，需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套。
# 你可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套字典
# 字典列表
alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]  # 将三个字典储存到列表里
for alien in aliens:  # 遍历列表
    print(alien)  # 返回的将是三个字典

# 创建多个字典
aliens = []  # 创建一个空列表
for alien_number in range(30):  # 使用range函数创建30个字典
    new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}  # 将字典储存到变量new_alien中
    aliens.append(new_alien)  # 然后将生成的字典添加到aliens列表里
# 修改字典中的键值对
for alien in aliens[0:3]:  # 遍历列表前三个元素
    if alien['color'] == 'green':  # 在aliens列表中，字典中的键color相关联green这个值得话，就执行缩进代码
        alien['color'] = 'yellow'  # 将字典中键color相关联的值修改成yellow
        alien['speed'] = 'medium'  # 将字典中键speed相关联的值修改成medium
        alien['points'] = 10  # 将字典中键points相关联的值修改成20

for alien in aliens[:5]:  # 遍历列表前5个元素
    print(alien)
print("...")
print(str(len(aliens)))  # 返回列表里有多少个元素(字典)

# 在字典中存储列表
pizza = {
    'crust': 'thick',
    'toppings': ['mushrooms', 'extra cheese'],
}

print("You ordered a " + pizza['crust'] + "-crust pizza " +
      "with the following toppings:")
for topping in pizza['toppings']:  # 遍历pizza字典中键toppings相关联的值，也就是那个列表
    print("\t" + topping)  # 将列表中的元素输出出来

# 字典中多个列表
favorite_languages = {
    'jen': ['python', 'ruby'],
    'sarah': ['c'],
    'edward': ['ruby', 'go'],
    'phil': ['python', 'haskell'],
}

for k, v in favorite_languages.items():  # 用for循环遍历字典中的键值对
    # print(k,v)	#如果直接这样输出的话，就不完美了
    print(k.title())  # 将字典中的键输出出来
    for language in v:  # 然后再遍历字典中的值，因为值是列表，所以返回的是列表中的每一个元素
        print("\t" + language.title())

# 在字典中存储字典
users = {
    'aeinstein': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton',
    },
    'mcurie': {
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
    },
}

for k, v in users.items():  # 遍历字典中的键值对，以列表的形式返回
    print(k)  # 输出字典中的键
    # 开始访问users字典中的内部字典
    # 变量 v 包含值中的字典，而该字典包含三个键：'first' 、 'last' 和 'location'
    full_name = v['first'] + " " + v['last']  # 访问值中的字典中键first相关联的值
    location = v['location']  # 访问值中的字典中键location相关联的值，然后将其存放到location变量中
    # 然后将其输出出来
    print('\t' + full_name.title())
    print('\t' + location.title())