Day2概要：
# 一、数据类型的使用
# 二、字符编码
'''
str list dict*****
int float bool tuple python2中存在的类型***
set*
字符编码概念***
字符编码的使用*****
三种字符串****
'''
数据类型
# py2中有long, py3中删除了该数据类型
# python3中：
# 1.所有整数都由int存储
# 2.所有小数都由float存储
# 3.complex为实数类型：存在实部和虚部
# int整型：存放年龄、个数等数据
a = 10
print(a, type(a), id(a)) #储存a的地址
# long长整数：存放大型整数 - 天文数字，身份证，电话号
# py3中所有整型都由int存储，无long类型
# 应用场景：存放整型数据完成算术运算
# 浮点型：存放所有小数
f = 3.1415
print("%10.2f" % f)
# 10为数据所占的位数，2代表小数位的个数，+为左对齐，-为右对齐
# 实数: complex，存放有实部与虚部的数
num = 4 + 5j
print(num)
num = complex(10, 3)
print(num)
bool类型：本质就是属于int
# bool类型：用来存储真 或 假 结果的值
# py2中没有bool类型，就是用0表示假，1表示真
# py3中引入的bool类型，本质还是用0表示假，1表示真
result = True
print(type(result))
# 判断一个对象是否是某个类型
print(isinstance(10, int))
print(isinstance(3.14, int))
print(isinstance(True, int))
print(True + True * True + True * False)
#计算机传输数据的原理
传输数据的载体：电：高低电频（字符串010010011101010）
字符串类型：所有编程语言最重要的类型
及其重要
#定义：
#''|""|''''''|""""""都表示字符串
# 双引号存在的意义：不同引号之间可以嵌套，""嵌套''，单引号原样输出，反过来双引号原样输出
# (a)'b'<c>
s5 = '(a)\'b\'<c>'
print(s5)
s6 = "(a)'b'<c>"
print(s6)
s7 = '(a)"b"<c>'
print(s7)
# 三引号存在的意义：多行字符串
s8 = '123\n456\n78\\9' #\表示转义，\\说明输出\，\n则为换行
print(s8)
s9 = '''123
456
789'''
print(s9) #输出多行字符串
# 前提：数据结构是有序的，才会有索引（排列顺序，从0开始代表正向，从-1开始代表反向）
# 1、索引：变量名[index] | 变量名[-index]
s10 = '123abc,呵呵'
print(s10[2], s10[-3]) # 结果：3 ,
# 2、切片：变量名[begin:end:step] => 目的：快速过去子字符串
s11 = '123abc,呵呵'
# 从索引3之前截取到索引-3之前，步长默认为1 [3:-3:1]==[3:-3:]==[3:-3]
print(s11[3:-3:1]) # 结果：abc
# 当步长为-1时，反向截取字符串 [-4:2:-1]==[-4:-7:-1]==[5:-7:-1]==[5:2:-1]
print(s11[-4:2:-1]) # 结果：cba
# 当步长绝对值不为1时，如为2，那就是截取1位后跳过1位截取下一位，如为-3，反向截取1位跳过2位截取下一位
print(s11[::2]) # 结果：13b,呵
print(s11[::-3]) # 结果：呵c3
# 3、拼接(重复)
s12 = 'you are'
s13 = 'good people!'
s14 = s12 + ' ' + s13
print(s14)
print(s14 * 3) #说三遍
# 4、成员运算：判断字符串中是否包含某子字符串，结果为True|False
s11 = '123abc,呵呵'
# 'a' 'ab' 'ac'，子字符串 小于等于 父字符串(字符串是连续的)
print('a' in s11) # True
print('ab' in s11) # True
print('ac' in s11) # False
# 5、元素个数(长度)
s12 = '123abc,呵呵'
print(s12.__len__()) # 9（方法）
print(len(s12)) # 9 建议（函数）
掌握
# 1.首尾去白
s1 = ' 123 '.strip() # 123
print(s1)
s2 = '** 123** *'.strip('*')
print(s2) # ' 123** '
s3 = ' 123 '.lstrip()
print(s3) # '123 '
s4 = ' 123 '.rstrip()
print(s4) # ' 123'
# 2.查找子字符串的索引(没有结果报错)
# index(子字符串, 开始查的位置, 结束查的位置) 后两个参数可以省略，一旦查询到一个结果就结束
s5 = '123abc,呵呵abc'
print(s5.index('a')) # 3
print(s5.rindex('a')) # 9
print(s5.index('a', 4, -1)) # 9
# find(子字符串, 开始查的位置, 结束查的位置)，使用同index，但是没有结果返回-1
print(s5.find('z')) # -1
# 3、拆分：将str转换为list ******
s6 = '1,2,3,4'
print(s6.split(',')) # ['1', '2', '3', '4']
# 4、组装：将list转换为str
ls = ['1', '2', '3', '4']
n_s6 = '@'.join(ls)
print(n_s6) # 1@2@3@4
# 5、子字符串的个数，没有返回0
s13 = '1212121'
print(s13.count('12')) # 3
# 6、替换：把目标字符串中的子字符串替换为指定字符串，可以设置替换次数
# replace(old, new, count)
s14 = 'owen is owen owen'
n_s14 = s14.replace('owen', 'Owen') # count省略默认全部替换
print(n_s14)
n1_s14 = s14.replace('owen', 'Owen', 2)
print(n1_s14)
# 7、数字判断
num = input("请输入一个数字：")
# 如果能被转换才转化
if num.isdigit(): # 是否是数字
num = int(num)
print(num, type(num))
# 补充：
# 8、大小写切换：lower | upper | title | capitalize | swapcase
# 全小写 | 全大写| 单词大小| 首字母大小 | 大小写反转
print('aBc'.lower()) # abc
print('aBc'.upper()) # ABC
print('aBc'.swapcase()) # AbC
print('abc def xzy'.capitalize()) # Abc def xzy
print('abc def xzy'.title()) # Abc Def Xzy
# 9、迭代(循环)
s15 = 'abcxyz'
for c in s15:
print(c)
了解
# 1、startswith | endswith：以某某开头 | 结尾
s1 = 'http://www.baidu.com'
print(s1.startswith('http://')) # True
print(s1.endswith('cn')) # False
# 2、格式化
# \d整数占位 \f小数占位 \s万能占位符 ***
s2 = '%s' % 10
print(s2)
s3 = '%s是一个%s，今年%s岁' % ('你', '好人', 58)
print(s3)
s4 = '{} is {}'.format('Owen', 'Teacher')
print(s4) # Owen is Teacher
s5 = '{1} is {0} {0}'.format('Owen', 'Teacher')
print(s5) # Teacher is Owen Owen
s6 = 'name:{n}，age:{a}'.format(n='Owen', a=16)
print(s6)
# 3、填充 center | ljust | rjust | zfill：按位填充
s7 = '分割线'.center(30, '+')
print(s7)
# 4、是否由字母组成(汉字也被纳入合法范围) => 就是用来批判是否是纯字母
print('abc汉字也被纳入合法范围'.isalpha())
# 5、是否由字母数字组成
print('abc123'.isalnum())
# 6、数字判断 isdigit | isdecimal | isnumeric：数字判断(不做小数判断)
s8 = '1' # isdigit isnumeric
s9 = '一' # isnumeric
s10 = '壹' # isnumeric
s11 = 'Ⅳ' # isnumeric
print('====================华丽分割线=================')
print(s8.isdigit())
print(s8.isdecimal())
print(s8.isnumeric())
print('====================华丽分割线=================')
print(s9.isdigit())
print(s9.isdecimal())
print(s9.isnumeric())
print('====================华丽分割线=================')
print(s10.isdigit())
print(s10.isdecimal())
print(s10.isnumeric())
print('====================华丽分割线=================')
print(s11.isdigit())
print(s11.isdecimal())
print(s11.isnumeric())
三种字符串
# 普通字符串：u'' | ''
s1 = u'abc\ndef'
print(s1)
# 原义字符串：r'' 字符串中的所有字符(保护特殊及转义字符)都会原样输出
s2 = r'abc\ndef=-_/'
print(s2)
s3 = r'D:\周末五期\day02\代码\6.字符串了解.py'
# 二进制字符串：b'' 字符串按字节为最小单位，用于存储和传输
s4 = b'a1\xe5\xad\x97'
print(s4, s4.decode('utf-8'))
列表类型
# 字符类型是所有编程语言最重要的类型
# 定义：
l1 = [1, 2, 3, 4, 5]
print(l1)
l2 = list()
print(l2)
l3 = list('abc')
print(l3)
# list类型诞生的理由: 存放多种类型的数据，也可以存放容器(list dict...)
l4 = [1, 2, 3, '1', [1, 2], [3, '1']]
print(l4)
# 1、索引：
l5 = [1, 2, 3, '1', [1, 2], [3, '1']]
print(l5[3], l5[-2], l5[-1][0])
# 2、切片：
l6 = [3, 1, 4, 2, 5]
print(l6[1:-1:2])
# 反转 [5, 2, 4, 1, 3]
print(l6[::-1])
# 需求 [2, 3]
print(l6[-2::-3])
# 3、拼接(重复)
print([1, 2] + [3, 4]) # [1, 2, 3, 4]
print([1, 2] * 3) # [1, 2, 1, 2, 1, 2]
# 4、成员运算：
l7 = [3, 1, 4, 2, 5, [3]]
print('3' in l7) # False
print(3 in l7) # True
print([3] in l7) # [3]不是匹配3而且匹配[3]
# 5、元素个数(长度)
l8 = [5, 2, 3, 1, 4]
print(len(l8))
# 1.正向排序
l9 = [5, 2, 3, 1, 4]
l9.sort()
print(l9) # [1, 2, 3, 4, 5]
# 2.反向排序
l10 = [5, 2, 3, 1, 4]
l10.sort(reverse=True) # 反排
print(l10) # [5, 4, 3, 2, 1]
l11 = [5, 2, 3, 1, 4]
l11.sort() # 排序
l11.reverse() # 反转
print(l11) # [5, 4, 3, 2, 1]
l12 = [5, 2, 3, 1, 4]
l12.reverse()
print(l12) # [4, 1, 3, 2, 5]
# 错误：排序前提 类型相同，且该类型可以比较
# l13 = [1, '2', [1, 2]]
# l13.sort()
# print(l13)
print([1, 2, 3, 1].count(1)) # 出现2次
print([1, 2, 3, 1].index(3)) # 索引为2
# 删增改查
l14 = [1, 2, 3]
# 查
print(l14[-1]) # 3
# 改
l14[0] = 100
# 增
# append(obj) 在末尾一次增加一个
l14.append(400)
# insert(index, obj) 在指定索引插入对象
l14.insert(2, 888)
# extend在末尾一次增加多个 iterable
l14.extend(['a', 'b', 'c', 2, 3])
# 删
res = l14.pop(2) # 拿出索引3位的对象
print(res)
l14.remove(888) # remove操作是明确删除的对象，所以不需要操作后形成结果
# 清空
l14.clear()
# 列表的循环
l15 = [1, 4, 3, 2, 5]
for obj in l15:
print(obj)
案例
# 求平均成绩:
# 从控制台录入成绩，如果录入的非0~100直接的数，重新录入，
# 录入q|Q结束录入得到平均成绩
# 存放成绩的list
score_list = []
while True:
num = input('请输入成绩：').strip()
# 如果是q或Q，退出
if num.lower() == 'q':
print('录入结束...')
break
# 将非数字、小数、负数都剔除了
if num.isdigit():
num = int(num)
if num <= 100:
score_list.append(num)
else:
print("数值过大...")
else:
print('数据非法...')
# 总成绩
score_total = 0
for score in score_list:
score_total += score
# 存放成绩的list得到平均成绩
print("平均成绩：%s" % (score_total / len(score_list)) )
元组类型：
# 元组类型：比list更省空间且只用来查询的list，不可变的list(只读的list)
# 定义：
t1 = (1, 2, 3)
print(t1)
t2 = tuple()
print(t2)
t3 = tuple('abc')
print(t3)
# 只有一个元素的元组
t4 = (100,)
print(t4)
t5 = (1, '2', [1, 2], (3, '4'))
print(t5)
# tuple可以理解为不可变的list
# 当一个list只需要用来读数据
# list => tuple
n_t5 = list(t5)
print(n_t5) # 可以增删改查
# 当一个tuple需要用来读写数据
# tuple => list
n_n_t5 = tuple(n_t5)
print(n_n_t5) # 只用来查
# 查
t6 = (1, '2', [1, 2], (3, '4'))
print(t6[1], t6[-1][1])
# 切片
print(t6[:2:])
字典：
# 定义：
d1 = {'name': 'Tom', 'age': 18} # *****
print(d1)
d2 = dict([('x', 1), ('y', 2)]) # ***** 可以完成list与dict快速转化
print(d2)
d3 = dict({'name': 'Tom', 'age': 18})
print(d3)
d4 = dict(name='Bob', age=17)
print(d4)
# dict快速转化为list
ls = list(d4.items())
print(ls) # [('name', 'Bob'), ('age', 17)]
# 字典存在的意义：
# 1、字典的数据不像list和tuple，数据的查询依据为索引(索引信息量少)
# 字典依赖有描述型key来查询数据
# 2、python中的字段，values是无序存储，字典增删插数据效率高，
# python中对字典的key做了有序优化，所以查询效率也不低
# dict的key可以为：int float str bool tuple complex，通常只用str
# dict的value可以为：任意类型
d5 = {0: 'Bob', 1: 17}
print(d5[0])
# 重点：dict中的key是访问值的关键，所以一定要保证唯一性，key不能重复
d6 = {1: 1, '1': 2, True: 3, 1: 4}
print(d6) # {1: 4, '1': 2}
# ==========================================================
# 增删改查
dic = {'name': 'Tom', 'age': 18}
# 查
print(dic['name'])
# 改
dic['name'] = 'Bob'
# 增
dic['height'] = 180
# 删
del dic['age']
print(dic)
# 总结：字段名[key] 不赋值就是查，赋值key不存在就是增，存在就是该，del字段名[key]就是删
# ==========================================================
# 1.取值
# 当key不存在，报错
# print(dic['score'])
# 安全的取值
dic['score'] = 100
# score这个key对应有值，就取出对应的值，如果没值(该可以不存在)，默认取出None，但也可以设置get第二个参数
# 表示取值失败，取出默认值
res = dic.get('score', 59)
print(res)
# 2.update：key有则覆盖内容，无则增加内容(可以增加多条)
dic2 = {'x': 1}
dic2.update({'x': 100, 'y': 200, 'z': 300})
print(dic2)
# 3.pop(k) popitem()
dic3 = {'x': 100, 'y': 200, 'z': 300}
# 从后往前取出 (k, v)
res = dic3.popitem()
print(res)
k, v = dic3.popitem()
print(k, v)
# 根据key取出对应的值
v = dic3.pop('x')
print(v)
# 清空
dic3 = {'x': 100, 'y': 200, 'z': 300}
dic3.clear()
print(dic3)
# ==========================================================
# 字典的循环
dic4 = {'x': 100, 'y': 200, 'z': 300}
for k in dic4:
print(k)
# dic4.keys()：拿到所有的key
for k in dic4.keys():
print(k)
# dic4.values()：拿到所有的key
for v in dic4.values():
print(v)
# dic4.items()：拿到所有的key-value键值对 (key, value)
for k_v in dic4.items():
print(k_v)
# 常用
for k, v in dic4.items():
print(k, v)
