# ASCII --> Latin1 --> Unicode编码
# 字符 --> 数字编码存在一个对应关系
# 使用内置函数 chr 和 ord 能够查看数字和字符的对应关系
# ord 获取字符对应的编码 chr 根据编码获取对应的字符
print(ord('a')) # 97
print(chr(65)) # A
print(ord('你')) # 20320
print(chr(415))
# GBK 国标扩，汉字占两个字节 GB2312就是GBK
# utf-8 统一编码，汉字占三个字节
# BIG5 大五码（繁体中文）
# 使用encode()方法，可以将字符串转换成为指定编码集结果
# 如果有一个编码集结果，想把它转换成字符串，可以用decode()方法
# GBK编码，一个汉字两个字节
print('你'.encode('gbk')) # b'\xc4\xe3' 50403 11000100 11100011
# utf8编码，一个汉字三个字节
print('你'.encode('utf8')) # b'\xe4\xbd\xa0' 11100100 10111101 10100000
x = b'\xe4\xbd\xa0'
print(x.decode('utf8'))
# 把 你好 使用GBK编码
y = '你好'.encode('gbk')
print(y)
print(y.decode('gbk'))
# print(y.decode('utf8')) 报错
z = '你好'.encode('utf8')
print(z)
print(z.decode('gbk')) # 浣犲ソ
print(y.decode('utf8')) # txt 文本乱码，修改字符集 word -->记事本打开
# 因为utf8是三个字节，两个utf8字符会转换成三个GBK字符
# in 和 not in 运算符
# 用来判断一个内容在可迭代对象里是否存在
word = 'hello'
x = input('请输入一个字符：')
# 判断用户输入的字符在字符串里是否存在
# for c in word:
# if x == c:
# print('存在')
# break
# else:
# print('不存在')
#
# if word.find(x) == -1:
# print('不存在')
# else：
# print('存在')
#
if x in word:
print('存在')
else:
print('不存在')
if x not in word:
print('不存在')
else:
print('存在')
# 可以使用 % 占位符来表示格式化一个字符串
name = 'zhangsan'
age = 18
print('大家好，我的名字是', name, '，我今年', age, '岁了', sep='')
#在字符串里可以使用%占位符
#%s ==> 表示的是字符串的占位符
#%d ==> 表示的是数字的占位符
#%nd ==> 表示的是数字的占位符,打印时显示n位，不够用空格补齐
#%f ==> 表示的是浮点数的占位符
#%.nf ==> 表示的是浮点数小数点后n位的占位符
#%x ==>将数字使用16进制输出
print('大家好，我的名字是%s，我今年%d岁了，挣了%f元钱' %(name, age, 3.14))
print('大家好，我是%3d号男嘉宾' % 5) # 大家好，我是 5号男嘉宾
print('大家好，我是%03d号男嘉宾' % 5) # 大家好，我是005号男嘉宾
print('大家好，我是%-3d号男嘉宾' % 5) # 大家好，我是5 号男嘉宾
print('我今天赚了%.2f元' % 3.14566) # 我今天赚了3.15元
a = 255
print(a)
print('十六进制为%x' % a) #十六进制为ff
print('十六进制为%X' % a) #十六进制为FF
print('大家好，我是%s,今年%d岁了' %('zhangsan', 56))
#大家好，我是zhangsan,今年56岁了
print('大家好，我是%%s,今年%d岁了' % 56)
#大家好，我是%s,今年56岁了
# {} 也可以进行占位
# {} 什么都不写，会读取后面的内容，一一对应填充
x = '大家好，我是{}，我今年{}岁了'.format('zhangsan',18)
print(x)
# {数字} 根据数字的顺序进行填入。数字从0 开始
y = '大家好，我是{1},我今年{0}岁了'.format(20, 'jerry')
print(y)
#{变量名}
z = '大家好，我是{name},我今年{age}岁了'.format(age=100, name='jerry')
print(z)
# 混合使用 {数字} {变量}
a = '我是{name},我{0}岁了'.format(45, name='li')
print(a)
# {} {数字}不可混合使用
#列表笨办法
d = ['zhangsan', 18, 'shanghai', 180]
b = '我叫{}， 我今年{}岁了，我来自{}，我身高{}'.format(d[0],d[1],d[2],d[3])
print(b)
#列表解包使用
u = '我叫{}， 我今年{}岁了，我来自{}，我身高{}'.format(*d)
print(u)
#字典解包
info = {'name':'chris', 'age':34, 'addr':'beijing', 'height':193}
c = '大家好，我是{name},今年{age}岁了，来自{addr},身高{height}cm'.format(**info)
print(c)
# 当我们有多个数据需要按照一定顺序保存时，可以考虑列表
# name1 = '张三'
# name2 = '李四'
# name3 = '王五'
# name4 = 'jerry'
# 使用[]来表示一个列表，列表里的每一个数据我们称为元素
# 元素之间使用逗号分隔
names = ['张三', '李四', '王五', 'jack', '张飞', '关羽', '马飞']
# 和字符串一样，可使用下标来获取元素和对元素进行切片
# 同时，我们还可以使用下标来修改列表里的元素
print(names[3])
names[3] = '花木兰'
print(names)
# 可以通过下标来切片
print(names[3:6])
x = 'hello'
print(x[1])
# x[0] = 'm' 字符串不能修改
# 使用list(可迭代对象)函数，将可迭代对象转换成列表 ('兰陵王'，'东皇太一'，'王昭君')
# names = list(('兰陵王','东皇太一','王昭君'))
# print(names)
# 列表是用来保存多个数据的，是有序可变的
# 操作列表 ，增删改查
heros = ['阿珂','嬴政', '韩信', '露娜', '后裔', '亚瑟', '李元芳']
#添加元素的方法 append insert extend
heros.append('黄忠')
print(heros) #在列表的最后面追加一个数据
# insert(index, object)
heros.insert(2, '狄仁杰')
print(heros)
# extend(可迭代对象)
x = ['马可波罗', '米莱迪', '李白']
heros.extend(x)
print(heros)
print(x)
masters = ['王昭君', '甄姬', '貂蝉', '妲己', '小乔', '大乔']
# 删除数据有三个相关的方法 pop remove clear
# pop 方法默认会删除列表里最后一个数据，并且返回这个数据
# pop还可以传入index参数，用来删除指定位置上的数据
x = masters.pop(3)
# print(x)
print(masters) # ['王昭君', '甄姬', '貂蝉', '小乔', '大乔']
# remove用来删除指定的元素
masters.remove('小乔')
#masters.remove('狄仁杰') 没有的元素，会报错
print(masters)
# 使用del 也可以删除一个数据（尽量不要用，有别的用法）
del masters[2]
print(masters)
# clear用来清空一个列表
masters.clear()
print(masters)
tanks = ['亚瑟', '程咬金', '盾山', '张飞', '廉颇', '程咬金']
# 查询相关的方法
print(tanks.index('盾山'))
# print(tanks.index('庄周')) 如果元素不存在就报错
print(tanks.count('程咬金'))
# in运算符
print('张飞' in tanks) # True
print('苏烈' in tanks) # False
# 修改元素
# 使用下标可以直接修改列表里的元素
tanks[5] = '铠'
print(tanks)
# 遍历：将所有的数据都访问一遍。遍历针对的是可迭代对象
# while循环遍历 / for ... in循环
killers = ['李白', '兰陵王', '韩信', '赵云', '阿珂', '孙悟空']
# for... in循环的本质就是不断的调用next方法查找下一个数据
for killer in killers:
print(killer)
# while循环
i = 0
while i < len(killers):
print(killers[i])
i += 1
a = 13
b = 20
#方法一：使用第三个变量做交换
# c = b
# b = a
# a = c
#方法二：使用运算符实现，只能是数字
# a = a+b
# b = a-b
# a = a-b
#方法三：使用亦或运算符
# a ^ b ^ b ==>a
# a = a ^ b
# b = a ^ b
# a = a ^ b
# 方法四：使用python特有
a, b = b, a
print(a) #20
print(b) #13
nums = [6, 5, 3, 1, 8, 7, 2, 4]
# 冒泡排序的思想：
# 让一个数字和他下一个数字进行比较运算
# 前一个若大于后一个就交换两个数字的位置
# nums[0] nums[1]
# nums[1] nums[2]
# ... ...
# nums[n] nums[n+1]
# ... ...
# nums[length - 2] nums[length - 1]
i = 0
while i < len(nums) - 1:
i += 1
n = 0
while n < len(nums) - 1:
# print(nums[n], nums[n + 1])
if nums[n] > nums[n+1]:
nums[n], nums[n+1] = nums[n+1], nums[n]
n += 1
print(nums)
nums = [6, 5, 3, 1, 8, 7, 2, 4]
# 调用列表的sort方法可以直接对列表进行排序
# 直接对原有列表进行排序
# nums.sort()
# nums.reverse()
# print(nums)
# 内置函数sorted，不会改变原有的列表数据，会生成一个新的有序数列
x = sorted(nums)
print(nums)
print(x)
names = ['zhangsan', 'lisi', 'wangwu']
names.reverse()
print(names)
#相当于
print(names[::-1])
#Python 里的数据都是保存在内存里面的
#Python 里的数据又分为可变类型和不可变类型
#不可变数据类型：字符串，数字，元组
#可变类型：列表，字典，集合
#不可变数据类型 如果修改值，内存地址会发生变化
#可变数据类型 如果修改值，内存地址不会发生变化
# 使用内置函数id，可以查看
a = 12
b = a
print('修改前，a=%x,b=%x' % (id(a), id(b)))
a = 10
print(b) #12
print('修改后，a={},b={}'.format(id(a), id(b)))
nums1 = [100, 200, 300]
nums2 = nums1
print('修改前nums1 = %x, nums2 = %x' % (id(nums1), id(nums2)))
nums1[0] = 1
print('修改后nums1 = %x, nums2 = %x' % (id(nums1), id(nums2)))
print(nums2) #[1, 200, 300]
x = [100, 200, 300]
y = x # x,y指向同一个内存空间，会互相影响
# 等号是内存地址的赋值
x[0] = 1
print(y)
# 调用copy方法，可以复制一个列表
# 新列表和原有列表的内容相同，但指向不同的内存空间
z = x.copy()
x[0] = 2
print(z)
print(y)
print('0x%X,0x%X,0x%X' % (id(x), id(y), id(z)))
# 出了使用列表自带的copy方法以外，还可以使用copy模块来实现拷贝
import copy
a = copy.copy(x) # 效果等价于b = x.copy() 都是一个浅拷贝
# 深拷贝
# 切片其实就是一个浅拷贝
names1 = ['张三', '李四', '王五', '杰克']
names2 = names1[::]
names1[0] = 'jerry'
print(names2)