# 整型 int
# =====基本使用=====
# 用途：存纯整数的数据类型，都是整数，自然数，不是小数的
# 定义方式：age = 18 # age= int(18)
# 注意：
# int('abc') # ValueError: invalid literal for int() with base 10: 'abc' 会报错，int不认识字母
# int ('1.1') # ValueError: invalid literal for int() with base 10: '1.1' 会报错，int不认识小数点
# int只能转纯数字的字符串，小数点都不行
# =====类型总结=====
# 存一个值
# 有序 or 无序 （不涉及是否有序）
# 有序： 但凡有索引的数据都是有序的
# 不可变
#
# 可变类型与不可变类型
# 可变类型：在值改变的情况下，id不变，说明改的是原值，说明值变了内存地址没有变，说明该内存地址中的数据变了，为可变类型
# 不可变类型：值改变的情况下，id一定变，说明变量指向了其他内存空间，原内存空间的值并没有发生变化，为不可变类型
#
# 进制转换：
# 其他进制转换成十进制
# 二进制转十进制 二进制位010100 例如二进制的 10 转为十进制：
# # 1*（2**1）+0*（2**0） = 2 等于十进制的2
# 十进制转二进制可以用除二取余法，结果（余数）从下往上写
# 八进制转十进制 八进制之有0-7 例如八进制的 235转为十进制
# 十进制转八进制可以用除八取余法，结果（余数）从下往上写
# 2*（8**2）+3*（8**1）+5*（8**0）=128+24+5=157 等于十进制的157
# 十六进制转十进制 0-9 A-F 比如十六进制的 217 转换成十进制：
# 2*(16**2) + 1*(16**1) + 7*(16**0) = 535 等于十进制的535
# print(int(1100,2))
# TypeError: int() can't convert non-string with explicit base
# 这样写会报错，int后面括号里第一个值必须用引号引起来，以字符串形式传参
# print(int('1100',2)) # 12
# print(int('14',8)) # 12
# print(int('c',16)) # 12
# int可以传递一个参数，表示的是第一个参数到底是几进制，然后转为十进制
#
# 十进制转其他进制
# 十进制转二进制
# print(bin(12)) # 0b1100 0b表示后面的数字是二进制数字
# # 十进制转八进制
# print(oct(12)) # 0o14 0o表示后面的数字是八进制数
# # 14八进制转十进制; 1*(8**1) + 4*(8**0))
# # 十进制转十六进制
# print(hex(12)) # 0xc 0x表示后面的数字是十六进制
# 浮点型
# 作用:薪资身高体重，带小数的数据为浮点型
# salary = 1.1 # float(1.1)
# res = float('1.11')
# print(type(res))
# 字符串
# =====基本使用=====
# 用途：描述性数据
# 定义方式：单引号，双引号，三单引号，三双引号
# s = 'hello baby' # str('hello baby')
# 注意：任何数据类型，加上引号，就是字符串
# s1 = str([1,2,3,4])
# print(type(s1))
# s2 = str({'name':'jason','password':123})
# print(type(s2))
# =====类型总结=====
# 存一个值
# 有序 有序：但凡数据有索引的 都是有序的
# 不可变类型，可hash : hash('abc') , 本身内存地址中的数据不会被修改，即值变，id也会变
# 按照索引取值 （正向取+反向取） ： 只能取，不能改
# s = 'hello world'
# print(s[4]) # 方括号中的4为索引，索引从零开始，所以取值为 第五个字母 o
# 切片（顾头不顾尾，步长）：从一个大字符串中取出一段新的小字符串
# s = 'hello world'
# print(s[0:5]) # hello
# print(s[0:5:1]) # hello 最后一个数字步长为1，不写，默认步长为1
# print(s[0:10:2]) # hlowr 步长为2 ，隔一个取一个，走两步取一个
# 负数取值
# s = 'hello world'
# print(s[-1])
# # 取值为d，-1表示区间前一个数，从倒数第一个，到倒数结束（到最后的可以省略），步长省略
# print(s[0:5:-2]) #切片默认从左往右切，从区间左边的索引位到右边的索引位
# # 取不到值，0-5，取01234，步长为-2，步长为向左，该区间取不到值
# print(s[5:0:-1]) #切片默认从左往右切，从区间左边的索引位到右边的索引位
# # 取到的值为 olle，区间为5到0，取54321，5为空格，h为0不取，步长-1，方向向左，依次取值，倒着取顺序与原值相反
# # 前两个值为区间，区间中左边固定就是头，右边固定就是尾，不按索引数字的大小来分头尾
# print(s[-1:-10:-1])
# # 切片左边索引位为倒数第一个，到倒数第十个，取-1到-9，不取倒数第十位，步长为-1，取值为 从右往左 一个一个取
# 长度len： 统计的是字符串中的字符的个数
# s1 = ' '
# print(len(s1)) # 空格也算一个长度，两个空格算两个字符长度，一个中文算一个字符长度
# 成员运算 in 和 not in
# 意思是判断一个子字符串是否存在于一个大的字符串中，结果位布尔值 True False
# print('a' in 'abc') # Ture
# print('ab' in 'abc') # Ture
# print('ab' in 'ab c') # Ture
# print('d' not in 'abc') # Ture
# print(not 'd' in 'abc') # Ture 与或非判断，并不是字符串的in 或者 not in的判断结果
# strip 去掉字符串左右两边的字符strip，不管中间的
# 使用内置方法通一采用 句点符（英文句号） .
# 使用场景，用户输入的用户名左右两边的空格，校验之前可以自动去掉
# username = input('please input your username>>>:').strip()
# # strip()括号中什么都不写，默认是取出字符串首尾的空格
# if username == 'xiao':
# print('welldone!')
# # 输入 xiao ，去掉左右两边空格后，满足if条件，welldone
# name1 = 'xiao'
# name2 = ' xiao '.strip()
# print( name1 == name2 ) # 结果为 True
# name3 = '#####xi#ao#####'
# print(name3.strip('#'))
# # 结果为xi#ao，只会去掉两边指定的字符，中间的不管
# name4 = '!@#$%xiao^&*()'
# print(name4.strip('!@#$%^&*()'))
# # 结果为xiao，会从两头开始，去掉两边指定的字符
# print(name4.lstrip('!@#$%'))
# # 结果为xiao^&*()，会从左边left开始，去掉左边的指定的字符
# print(name4.rstrip('^&*()'))
# # 结果为!@#$%xiao，会从右边right开始，去掉左边指定的字符
# 切分split
# split：针对按照某种分割符组织的字符串，可以用split将其分割成列表，进而进行取值
# split 分割的结果为 一个列表 list
# data = 'xiao |123 | 18'
# print(data.split('|'))
# # 输出结果为 ['xiao ', '123 ', ' 18']
# # 输出结果为一个列表，可以用解压赋值的方式取值，赋值给不同变量，打印看结果
# username,password,age = data.split('|')
# print(username,password,age)
# data = 'xiao |123 | 18'
# print(data.split('1')) # 切割顺序从左往右,引号引起来的1，视为字符串中的分割符，切分后，分隔符不存在
# # 结果为 ['xiao |', '23 | ', '8']
# print(data.split('i',1)) # 括号中引号引起来的i为分隔符，1没有用引号，1是切割次数，切割一次，结果为两个数据
# # 结果为 ['x', 'ao |123 | 18']
# print(data.rsplit('1',1)) # rsplit('1',1),以1为分隔符，从右right开始往左切，切一次，效果如下
# # 结果为 ['xiao |123 | ', '8']
# print(data.split('1')) # ['xiao |', '23 | ', '8']
# print(data.rsplit('1')) # ['xiao |', '23 | ', '8']
# # 如果不指定切割次数，split() 和 rsplit() 效果是一样的
# # 循环
# data = 'xiao |123 | 18'
# for i in data:
# print(i)
# # 每个字符打印一行，包括空格，|
# # lower upper
# s = 'HeLlOw WoRlD'
# res = s.lower()
# print(res) # hellow world 全变成小写
# print(s) # HeLlOw WoRlD 没有改变原字符串 s
# print(s.upper()) # HELLOW WORLD 全变成大写
# print(s) # HeLlOw WoRlD 没有改变原字符串 s
# # print(s)时，结果与原字符串相同，调用字符串大小写转换方法时候，并没有改变字符串本身
# # startswith 判断是否以什么什么开头
# # endswith 判断是否以什么什么结尾
# s = 'HeLlOw WoRlD'
# print(s.startswith('h')) # 结果为False，判断时大小写敏感
# print(s.startswith('H')) # 结果为True，判断时大小写敏感
# print(s.endswith('D')) # 结果为True，判断时大小写敏感
# print(s.endswith('d')) # 结果为False，判断时大小写敏感
# format 的三种方法（python推荐使用format做格式化输出，还有 %s %d 可以做格式化输出）
# #第一种方法; 按位置占位 跟 %s 原理一致
# str1 = 'my name is {} my age is {}'.format('xiao',18)
# print(str1) #结果为 my name is xiao my age is 18 ，先来先占
# str2 = 'my name is {} my age is {}'.format(18,'xiao')
# print(str2) #结果为 my name is 18 my age is xiao ，先来先占
# # 第二种方法：按索引占位
# str1 = 'my name is {1} my age is {1}'.format('xiao',18)
# print(str1)
# # 结果为 my name is 18 my age is 18 ，前面字符串中花括号中写的是方法中指名的值的索引位
# # 第三种方法： 指名道姓（关键字传参）
# str1 = 'my name is {name} my age is {age}'.format(name = 'xiao',age = 18)
# print(str1)
# # 结果为： my name is xiao my age is 18
# jion 将容器中多个字符串拼接成一个大的字符串，引号中为连接符
# data = 'xiao|123|18'
# res_list = data.split('|') # 切分字符串的结果为一个列表，那就把结果命名为list方便看
# print(res_list)
# res_str = '$$$'.join(res_list)
# print(res_str)
# # 结果为 xiao$$$123$$$18
# # 将容器中多个字符串拼接成一个大的字符串，引号中为连接符
#
# L = [1,'a','b'] # 报错TypeError: sequence item 0: expected str instance, int found
# L = ['1','a','b'] #被拼接的列表中，必须都为字符串，有一个整型或者浮点型数据，会报错，不可被拼接
# res = '|'.join(L)
# print(res)
# # L = ['1','a','b'] 的结果为正确的 ：1|a|b
# # replace 替换字符串中的值，可以替换几次，可以全局替换
# str1 = 'abc a b c a'
# res = str1.replace('a','x',1)
# print(res) # xbc a b c a
# # 将字符串中的a，替换为x，替换1次
# # replace括号中第一个字符串为原字符串中将被替换的字段，第二个为新字符串，第三个为次数
# print(str1) # abc a b c a
# # 替换后不是修改原字符串，而是生成一个新的字符串
# res = str1.replace('a','x',2)
# print(res) # xbc x b c a
# print(str1) # abc a b c a
# # 将字符串中的a，替换为x，替换2次
# # res = str1.replace('原字符串','新字符串','替换次数')
# res = str1.replace('a','x')
# print(res) # xbc x b c x
# print(str1) # abc a b c a
# # 将字符串中的a，替换为x，全部替换，不写次数默认全字符串替换
# # isdigit 判断字符串中是否为纯数字，纯整型，浮点型带.
# while True:
# age = input('your age>>:') # 请用户输入age，因该是纯数字，整数，整型
# if age .isdigit(): #判断，客户输入的字符串内容是否为纯数字
# age = int(age) #如果是则运行这个，将input存的字符串转换为整型，方便后面做运算
# if age > 28:
# print('阿姨好!')
# else :
# print('说人话！')
# find,rfind,查找 index,rindex,索引值 count 数数，计数
# s = 'a b c d e f g h '
# print(s.find('a')) # 返回0，返回的是该字符串在大字符串中的索引值
# print(s.find('abc')) # 返回-1，没有abc字段，空格算一个字符，占索引号，找不到时，不报错，返回的是-1
# print(s.find('b',0,3)) # 结果是 2
# # 可以定查找范围，print(s.find('需要查找的字符串',查找范围的起始索引，查找范围的最后索引))
# print(s.index('c'))
# # 结果是 4 ，结果返回字符串的索引值，返回值为4
# print(s.index('c',0,5))
# # 结果是4，范围查找：print(s.index('需要查找的字符串',查找范围的起始索引，查找范围的最后索引))
# # print(s.index('c',0,4))
# # 结果是报错，顾头不顾尾，索引是4，不再查找范围内，报错：ValueError: substring not found
# print(s.count('d')) # 结果为 1，统计该字符出现的次数
# center ljust rjust zfill
# s2 = 'abc'
# print(s2.center(12,'*'))
# # 结果为 ****abc***** print(s2.center(字符串总长度,'用什么补齐')) s2在中间 居中
# print(s2.ljust(12,'*'))
# # 结果为 abc********* print(s2.ljust(字符串总长度,'用什么补齐')) s2在最左边 左对齐
# print(s2.rjust(12,'*'))
# # 结果为 *********abc print(s2.rjust(字符串总长度,'用什么补齐')) s2在最右边 右对齐
# print(s2.rjust(12,' '))
# # 结果为 abc print(s2.rjust(字符串总长度,'用什么补齐')) s2在最右边 右对齐 补充字符串可以为空格
# print(s2.zfill(12))
# # 结果为 000000000abc print(s2.zfill(字符串总长度,'用什么补齐')) s2在最右边 右对齐 补充字符串可以为0
# # expandtabs
# s = 'a\tbc'
# print(s.expandtabs(2)) # 结果为 a bc， 功能为自动在字符串中增加tab，四个空格
# # captalize swapcase title
# s = 'hElLo WoRlD'
# print(s.capitalize()) # 结果为 ：Hello world ， 整个字符串首字母大写
# print(s.swapcase()) # 结果为 ： HeLlO wOrLd， 全字符串中的大小写互换
# print(s.title()) # 结果为 ： Hello World， 全字符串中每一个单词的首字母大写
# is数字系列
# num1 = b'4' # b'4'表示 4是bytes类型
# num2 = u'4' #u'4'表示4 是unicode，python3中不用加u就是unicode
# num3 = '肆' # 中文数字
# num4 = 'Ⅳ' # 罗马数字
# # print(num1.isnumeric()) # 报错AttributeError: 'bytes' object has no attribute 'isnumeric'
# print(num2.isnumeric()) # Ture .isnumeric()只要是数字都识别
# print(num3.isnumeric()) # Ture
# print(num4.isnumeric()) # Ture
# # ''.isnumeric() : unicode,中文数字，罗马数字 只要是表示数字都识别
# # ''.isdecimal(): unicode 只识别普通的阿拉伯数字
# print(num2.isdecimal()) # Ture
# print(num3.isdecimal()) # False
# print(num4.isdecimal()) # False
# # ''.isdigit() :bytes,unicode 通常情况下使用isdigit就已经满足需求了
# print(num1.isdigit()) # Ture
# print(num2.isdigit()) # Ture
# print(num3.isdigit()) # False
# print(num4.isdigit()) # False
# 列表类型
# =====基本使用=====
# 用途：多个装备，多个爱好，多门课程，多个女朋友等
# 定义方式：[]内可以有多个任意类型的值，逗号分隔，方括号内，值之间用英文逗号隔开
# s = ['a','b','c'] # s = list(['a','b','c'])
# list 在定义一个列表时，内部原理就是for循环取值，然后一个一个放进去
# L = list({'name':'xiao','age':18})
# print(L) # 结果为 ['name', 'age']
#内部原理就是 从字典中for循环取key值，然后一个一个放到列表里，组成新的列表
#
# =====类型总结=====
# 存多个值
# 有序 有索引即有序
# 可变： 不可hash
# L = list({'name':'xiao','age':18})
# hash(L) # 报错： 不可hash ， TypeError: unhashable type: 'list'
#按照索引取值（正向存取，反向存取）：可以存值 也可以取值
# l = [1,2,3,4]
# print(l[0:4:1]) # 结果为 [1, 2, 3, 4]
# print(l[0::]) # 结果为 [1, 2, 3, 4]
# # print(l[取值区间开始:取值区间结束:取值的步长])
# # 取值区间结束不写默认为末尾，取值步长不写默认为1
# print(l[5::-1]) # 结果为 [4, 3, 2, 1] 取值索引区间为5开始，默认到最前面，步长为向左挨个去取
# print(l[-1:-5:-1]) # 结果为 [4, 3, 2, 1] 取值索引区间为倒数第一个到倒数第五个，步长为倒着挨个去取
# print(l[0:4:2]) # 结果为 [1, 3] 取值步长为2
# # 改值
# print(id(l)) #l的内存地址为 2087588377096
# l[0] = 69 # 列表索引为0的值，第一个值修改为69
# print(l) #列表索引为0的值，第一个值修改为69，修改结果为 [69, 2, 3, 4] 修改成功
# print(id(l)) #l的内存地址为 2087588377096
# # 证明了列表时可变，值发生了改变，内存地址没有变，说明，内存地址中的值被修改了，列表可以被修改
# # # 切片 （顾头不顾尾的区间 步长）
# l = [11,22,33,44,55,66]
# print(l[0:5]) # 结果为 [11, 22, 33, 44, 55]
# # print(列表[切片区间开始:切片区间结束:切片步长]) 步长不写默认为1，区间结束值娶不到，顾头不顾尾
# print(l[0:5:2]) # 结果为 [11, 33, 55]
# # print(列表[切片区间开始:切片区间结束:切片步长]) 步长为2，隔一个切一个
# print(l[::-1]) # 结果为 [66, 55, 44, 33, 22, 11]
# # 步长为负数 从右往左 步长为一，区间不写默认全切，效果就是 从最后一个取值到第一个，列表倒过来
# # 尾部添加一个66 append
# l = [11,22,33,44,55]
# l.append(66) # 添加一个值
# print(l) # 结果为 [11, 22, 33, 44, 55, 66]
# l.append([1,2,3]) # 添加一个列表
# print(l) # 结果为 [11, 22, 33, 44, 55, 66, [1, 2, 3]]
# # 注意：append值能将被添加的数据当作列表的一个元素
# 任意位置添加元素 insert
# l = [11,22,33,44,55]
# l.insert(100,66) # 添加一个值 根据索引位 100，添加一个66 ，索引值大于总索引数，则在最后
# print(l) # 结果为 [11, 22, 33, 44, 55, 66]
# l.insert(-2,66) # 添加一个值 根据索引位 100，添加一个66
# print(l) # 结果为 [11, 22, 33, 44, 66, 55, 66] 索引位为[-3，-2，-1，0]
# l.insert(4,[1,2,3]) # 添加一个列表 索引位为4
# print(l) # 结果为 [11, 22, 33, 44, [1, 2, 3], 66, 55, 66] 添加进去是一个元素
# 3.添加容器类型数据
# append
# l = [1,2,3,4]
# l1 = [11,22,33,44,55]
# l.append(l1)
# print(l) # 结果为 [1, 2, 3, 4, [11, 22, 33, 44, 55]]
# # 将列表l1加到l中
#
# extend
# l = [1,2,3,4]
# l1 = [11,22,33,44,55]
# l.extend(l1) # 内部原理for循环l1取值一个个追加到列表的尾部
# print(l) # 结果为 [1, 2, 3, 4, 11, 22, 33, 44, 55]
# l.extend([1])
# print(l) # 结果为 [1, 2, 3, 4, 11, 22, 33, 44, 55, 1] 取值列表中的1 加到尾部
#
# insert
# l = [1,2,3,5]
# l1 = [11,22,33,44,55]
# l.insert(-1,l1)
# print(l) # 结果为 [1, 2, 3, [11, 22, 33, 44, 55], 5]
# # 将列表l1再加到l中，索引位为-1，即倒数第二个，索引位为[-3，-2，-1，0]
# 长度 len
# l = [1,2,3,4]
# print(len(l)) # 结果为4 ，计算列表中元素的个数，列表的总长度
# # 成员运算 in not in
# l = [1,2,3,4]
# print( 444 in l) # 结果为 False
# print( 1 in l) # 结果为 Ture
# # 删除
# l = [1, 2, 3, 4]
# print(l)
# del l[2] # 删除索引值为2的数值 是 3
# print(l) # 运行结果为 [1, 2, 4]
# # 尾部弹出 pop
# l = [1,2,3,4]
# res1 = l.pop() # 尾部弹出
# res2 = l.pop()
# res3 = l.pop()
# print(res1,res2,res3) # 结果为 4 3 2 从列表中一个一个弹出
# # 有返回值，返回值为弹出的值，4，3，2，可以赋值给变量，如上
# print(l) # 结果为 [1]
#
# l = [1,2,3,4]
# res1 = l.pop(2) # 按索引弹出
# print(res1) # 结果 ： 3
# print(l) # 结果 ： [1, 2, 4] 弹出索引为2的值 3
# #指定要删除的元素的值
# l = [11,22,33,44]
# res = l.remove(33) # 指定要删除的元素的值，33不是索引位，是列表中的值
# print(l) # 结果为 [11, 22, 44] 从列表中删除了33
# print(res) # None 没有返回值，直接删除了，这个跟pop不一样
# #循环
# l = [1,2,3,4]
# for i in l:
# print(i)
# # 循环取值 结果为： 1234每个数值各打印一行，print自带换行
浙公网安备 33010602011771号