python 备选
4.1 Number 数字
数据类型是不允许改变的
整数：int 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，布尔(bool)是整型的子类型。
浮点数：float 浮点型由整数部分与小数部分组成
复数：complex 复数由实数部分和虚数部分构成
主要用计算，使用不多，记住以下就行：
加：+ 减：- 乘：* 除： / 取余：% 整除：// 幂：**
取值范围：
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
i= 5.8 # 浮点数
print(int(i)) # 转换位 整数 精度损失
s = str(i) # int 转换为字符串 b = bool(i) # int 转换为布尔值 只有0是False 非0都是True
bool ：布尔型 ，如：True、False
True 真 1
False 假 0
注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加 True==1，False==0 是会返回 Ture，但可以通过 is 来判断类型。
# 同上 布尔值转换为int 只 能输出 0 和 1 i = int(True) b = int(False) while True: pass while 1: # 这个效率更高，因为电脑只识别0101二进制，True还要转换以下 pass
4.2 字符串 String：一般用英文：'内容' , "内容" , ''' 内容：多行''' ，
可以相加，可以数字加乘，存放少量数据
同上 字符串转换为 int 或布尔值 c = "123" b = int(c) # 注：字符串转换为int 前提条件必须是 数值类型 字符串转换为布尔值 s = "" --> False #非空字符串都是True s if s: print('你输入的为空，请重新输入') else: pass
# 字符串的索引与切片 s = 'ASDFGHJKL' #索引 字符串有一定顺序，且从0开始 s1 = s[0] # 新的s1与上面的s已经没有任何关联 print(s1) >> A s3 = s[-1] # 如果字符串很长，我又去最后几位 就可以倒着取 print(s3) >> L # 切片 取前不取后 s2 = s[0:4] # 不影响s哦 print(s2) >> ASDF s4 = s[0:] # 全部取，你以为是 = [0:-1] 你会发现最后一位没取，记得取后不取前 s5 = s[:] # 也可以这样写哦！ print(s4,s5) >> ASDFGHJKL ASDFGHJKL # 跳这取 s[首:尾:步长] s6 = s[0:6:2] print(s6) >> ADG # 倒着切 s7 = s[4:0:-1] print(s7) >> GFDS s8 = s[4::-2] # 倒着跳取 到最前面那位 print(s8) >> GDA s9 = s[-1::-1] # 倒着取完 print(s9) >> LKJHGFDSA s10 = s[::-1] # 倒着取完另一种方法 print(s10) >> LKJHGFDSA
# 字符串的操作
s = 'asdfghj'
# capitalize 首字母大写
s1 = s.capitalize()
print(s1)
>> Asdfghj
# upper 全部大写
s2 = s.upper()
print(s2)
>> ASDFGHJ
'''
# 一道题 请输入验证码的题
s21 = 'sdFG'
s22 = input("请输入验证码，不区分大小写 ")
if s21.upper() == s22.upper():
print('验证码正确')
else:
print('验证码错误')
'''
# lower 全部小写
s3 = s.lower()
print(s3)
>> asdfghj
# swapcase 大小写翻转
s4 = s.swapcase()
print(s4)
>> ASDFGHJ
# title 每个隔开（特殊字符或数字）单词首字母大写
s5 = 'asd vbn fgh'
s51 = s5.title()
print(s51)
>> Asd Vbn Fgh
# center 填充
s6 = s.center(20) # 居中填充 不写默认空白填充
s61 = s.center(10,'*') # 可以跟参数 10是算字符串总的为 不满用参数填充
print(s6,s61)
>> asdfghj *asdfghj**
# \t 加上前面所占不到8位补8位，超过8位不足16位补16位
s7 = 'fg\tkl'
s71 = s7.expandtabs()
print(s71)
>> fg kl
# len 计算字符串长度
s8 = len(s)
print(s8)
>> 7
# startswith 判断字符串是否以什么开头只能返回 True和False ，后面不加条件 就判断整体
s9 = 'asdDFG'
s91 = s9.startswith('a')
s92 = s9.startswith('d',2,5) # 可以切片判断
print(s91,s92)
>> True True
# find 通过元素 找元素所占的索引，找不到就返回-1
s9 = 'asdDFG'
s10 = s9.find('D')
s101 = s9.index('D') # 另一种方法 找不到会报错 ，首选find
print(s10,s101)
>> 3 3
# strip 删除前后元素 默认删除前后空格
s11 = ' hjkl '
s111 = s11.strip()
s112 = '$%kljflk*'
s113 = s112.strip('*$%') # 可以加参数，里面不按顺序
s114 = s112.rstrip('*$%') # 从右删，左边不动，同理 lstrip：从左删 右边不动
print(s111,s113,s114)
>> hjkl kljflk $%kljflk
# 附一道小题
# username = input('请输入你的名字：')
# if username.strip() == '小米':
# print('答对了')
# count 计数
s12 = s.count('a') # 数字符串所有的元素，也可以两个一起'as'
print(s12)
>> 1
# split 分割 也是字符串转换成列表的一种方式
s13 = 'kjh jkjhk kjhjk'
s131 = s13.split() # 括号里是参数，分隔后参数是不显示的
print(s131)
>> ['kjh', 'jkjhk', 'kjhjk']
str.split(str="", num=string.count(str)) # 第一个是以哪个参数分割 ，num这个字符串里有多个参数 分割次数，num有指定值则分割num+1，默认为-1，即分割所有 s = 'alexwusirlex' li = s.split('l',1) # 以l分割第一个 print(li) #>> ['a', 'exwusirlex']
#format 格式化输出
s14 = '我叫{},今年{},喜欢{}'.format('huang',25,'girl')
s141 = '我叫{0},今年{1},喜欢{1}'.format('huang',25,'girl')
s142 = '我叫{name},今年{age},喜欢{hobby}'.format(name='huang',age=25,hobby='girl')
print(s14,s141,s142)
>> 我叫huang,今年25,喜欢girl 我叫huang,今年25,喜欢25 我叫huang,今年25,喜欢girl
# replace 替换
s15 = '我来看你了你知道吗你知道吗'
s151 = s15.replace('知道','haha',1) # 替换 目标，值 ，有相同的第几个
print(s151)
>> 我来看你了你haha吗你知道吗
tuple：元组，元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。
例：（1，2，3）（"a","b","c"）
# 元组 只读列表 可循环查询 可切片 儿子不能改 孙子可能可以改
ts = ('name','age','column',[1,2,'hello'],'man')
print(ts[3][2]) # 查
>> hello
ts[3][2] = ts[3][2].upper() # 改孙子元素
print(ts)
>> ('name', 'age', 'column', [1, 2, 'HELLO'], 'man')
ts[3].append('ha') # 添加
print(ts)
>> ('name', 'age', 'column', [1, 2, 'hello', 'ha'], 'man')
# python range() 函数可创建一个整数列表，一般用在 for 循环中。 # # 函数语法 # range(start, stop[, step]) # 参数说明： # start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）; # stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5 # step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1) for i in range(0,10): # (开始，结束，步长) print(i) >> 0 1 2 3 4 5 6 7 8 9 for s in range(10,0,-2): print(s) >> 10 8 6 4 2 for d in range(3,-10,-2): print(d) >> 3 1 -1 -3 -5 -7 -9
# 一道题 两种方法参考
li = [1,2,3,5,'alex',[2,3,4,5,'taibai'],'afds'] # 都打印出来 包括里面的列表元素
# for i in li:
# if type(i) == list:
# for k in i:
# print(k)
# else:print(i)
for i in range(len(li)):
if type(li[i]) == list:
for j in li[i]:
print(j)
else:print(li[i])
list：列表：[] 括起来，每个元素以逗号隔开，可以存储大量数据，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。
而且列表是有序的，有索引值，可切片，方便取值。
# 列表 增删改查
# 增加 append 还在基础上增加 没有创建新的
p.append('happy,new year')
print(p)
# HR 输入名字 持续增加 当输入Q的时候 就退出
# while 1:
# username = input('>>>')
# if username.strip().upper() == 'Q':
# break
# else:
# p.append(username)
# print(p)
# insert 插入
p.insert(4,'老铁')
print(p)
# extend 插入可迭代的元素
p.extend('你好')
p.extend([1,2])
print(p)
# 删 pop
p2 = p.pop() # 有返回值 不填参数 默认删最后一个
p21 = p.pop(4) # 指定索引位删
print(p,p2,p21)
# remove 按元素删
p.remove('i love you')
print(p)
# clear 清空列表 但不删列结构
p.clear()
print(p)
# del
del p[0:2] # 切片删
del p # 全删包括列
print(p) # 你会发现报错 ，因为没有了，所以他肯定报错
# 改
p[0] = '你好' # 直接对应的 索引位改
p[0] = [4,5,6] # 也可以直接改列表
p[0:3] = '你好' # 把前三个删了 划分到最小的元素添加
p[0:3] = ['hao','ba'] # 添加列表里每一个元素
print(p)
# 查
print(p[0:4]) # 直接查
l = len(p) # 查列表长度
print(l)
# count 查一个元素的次数
print(p.count('ba'))
# index 查元素在列表中的索引位
print(p.index('hao'))
# sort 排序
s = [1,6,5,9,10]
s.sort() # 正向排序
print(s)
s.sort(reverse = True) # 倒向排序
print(s)
s.reverse() # 翻转
print(s)
# 列表的嵌套
t = ['xiaomi','haha','happy new year',1,2]
print(t[1][1]) # 找里面元素的元素
name = t[1].capitalize() # 所选的元素的首字母大写，但里面本质没有改变
print(name)
print(t)
t[0] = name # 这样里面元素已经改变
print(t)
print(t[2].replace('h','好')) # 里面元素替换
t[2] = t[2].replace('h','好')
print(t)
# 列表转换成 字符串 join 字符串转换成列表 split s ='huang' s1 = '+'.join(s) # 可以对可迭代对象任何操作 print(s1) #>> h+u+a+n+g # ''.join() li = ['alex','wusir','rain'] s2 = ''.join(li) print(type(s2)) print(s2) #>> <class 'str'> #>> alexwusirrain
dict：字典，用{ } 括起来，key不存在重复
'''
# dict
# 数据类型划分：可变、不可变
# 不可变 ：元组、bool、int、str 可哈希
# 可变：list、dict、set 不可哈希
# dict key 必须是不可变得数据类型 可哈希
value 任意数据类型。
dict 优点：二分查找去查询、存储大量的关系型数据
特点：3.5版之前是无序的
'''
dict = {
'name':'小米',
'age':'18',
'p1':[{'xuexi':15},20]
}
# 增
dict['hello'] = 'world'
print(dict)
# >> {'name': '小米', 'age': '18', 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}
# 如果有了 会直接覆盖掉
dict['age'] = 25
print(dict)
# >> 'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}
# setdefault
dict.setdefault('身高') # 没有vlaue会填充None
print(dict)
# >> {'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
dict.setdefault('age','20') # 对里面有键值对，不做任何改变，没有参会添加
print(dict)
# >> {'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
# 删
# pop
print(dict.pop('age')) # 有返回值
print(dict)
# >> 25
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
print(dict.pop('age',None)) # 如果字典里没有你要删除的键值对，你就要加个返回值，可自定义 防止报错飘红
print(dict)
# >> None
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
# popitem
print(dict.popitem()) # 删除最后一个，3.5以前随机删除 ，返回值 删除的键值对
print(dict)
# >> ('身高', None)
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}
# del
del dict['name'] # 所在键值对不在时会报错
print(dict)
# >>{'p1': [{'xuexi': 15}, 20], 'hello': 'world'}
dict.clear() # 清空字典
print(dict)
# >> {}
# 改
# 直接改
dict['age'] = 18
print(dict)
# >> {'age': 18}
# update
dict1 = {'name':'xiaomi','hello':'world'}
dict.update(dict1) # 把dict1的全部键值对 添加到 dict ，相同的覆盖
print(dict1)
print(dict)
# >> {'name': 'xiaomi', 'hello': 'world'}
# >> {'age': 18, 'name': 'xiaomi', 'hello': 'world'}
# 查
print(dict.keys())
print(dict.values())
print(dict.items())
# >> dict_keys(['age', 'name', 'hello'])
# >> dict_values([18, 'xiaomi', 'world'])
# >> dict_items([('age', 18), ('name', 'xiaomi'), ('hello', 'world')])
v1 = dict['name'] # 输出是值，没有就会报错
print(v1)
# >> xiaomi
# get
print(dict.get('name')) # 有就会直接返回值 没有就会返回None
print(dict.get('name2','没有这个值')) # 也可以自定义
# >> xiaomi
# >> 没有这个值
a,b = 1,2
a,b = [1,2]
a,b = [1,2],[3,4]
print(a,b)
# >> 1 2
# >> 1 2
# >> [1,2] [3,4]
# 用一行代码把 a b 值交换
a = 1
b = 2
a,b = b,a
print(a,b)
# >> 2 1
# 一一对应，接受值
for k,v in dict.items():
print(k,v)
# 嵌套
dic = {
'name':['xiaomi','zhangsan','lisi'],
'jihe':{
'time':'123',
'learn_money':19800,
'leader':'huang'
},
'age':18
}
# 改
dic['age'] = 25
print(dic)
#>> {'name': ['xiaomi', 'zhangsan', 'lisi'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['name'].append('leader')
print(dic)
# >> {'name': ['xiaomi', 'zhangsan', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['name'][1] = dic['name'][1].upper() # 其中一个值改大写
print(dic)
# 》{'name': ['xiaomi', 'ZHANGSAN', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['jihe']['gou'] = 8
print(dic)
# >> {'name': ['xiaomi', 'ZHANGSAN', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang', 'gou': 8}, 'age': 25}
# 一道题
f = input('>>>')
for i in f:
if i.isalpha():
f = f.replace(i,'')
o = f.split()
print(o)
print(len(str(o)))
set：集合，用{ } 括起来，集合是无序的，不重复的数据集合，里面的元素是不可变类型
# is 比较，比较的事内存地址
'''
# 集合：可变的数据类型，它里面的元素必须是不可变得数据类型，无序，不重复，{}
set = {1,'sdfsd',2,3,'hello'}
# add 增加
set.add("name")
print(set)
# >> {1, 2, 3, 'name', 'sdfsd', 'hello'}
# update
set.update('leader')
print(set)
# >> {1, 2, 3, 'hello', 'a', 'd', 'name', 'l', 'r', 'sdfsd', 'e'}
# pop 删除
set.pop()
print(set.pop()) # 随机删除 有返回值
print(set)
# 》 1
# 》 {2, 3, 'd', 'r', 'l', 'sdfsd', 'hello', 'a', 'e'}
# remove
set.remove(2) # 按元素去删
print(set)
# 》{'sdfsd', 1, 3, 'hello'}
# clear 清除集合
set.clear()
print(set)
# >> set()
# del 删除整个集合
del set
print(set)
# >> <class 'set'>
# 查
for i in set:
print(i)
# 求交集
set1 = {1,2,3,4,"hello"}
set2 = {1,4,2,5,"world"}
set3 = set1 & set2 # 第一种
print(set3)
# >> {1, 2, 4}
print(set1.intersection(set2)) # 第二种
# 》 {1, 2, 4}
# 求并集
print(set1 | set2)
# 》 {1, 2, 3, 4, 5, 'world', 'hello'}
print(set1.union(set2))
# >> {1, 2, 3, 4, 5, 'world', 'hello'}
# 反差集
print(set1 - set2)
# 》 {'hello', 3}
print(set1.difference(set2))
# >> {3, 'hello'}
# 子集 超集
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，若返回True 则set1是set2子集
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，若返回True 则set2是set1超集
'''
# set 本身是可变数据类型，但可以让他变成不可变数据类型，冻住
s = frozenset('barry')
print(s,type(s))
# >>frozenset({'b', 'r', 'a', 'y'}) <class 'frozenset'>
# 一道小题 去重
li = [11,22,33,33,44,55,66,66,77]
set5 = set(li)
print(set5)
li = list(set5)
print(li)
complex：复数
float：浮点型 ，如：12.20
注：
type()：查看数据类型的方法
字符串转换成数字：int(str) ，条件str必须是数值组成
同样数字转换成字符串：str(int)
用户交互input输出的全部是 str
