整型，int 所有的功能，都放在int里
# python3里，不管数字有多大都是int类型
# python2里，超过一定的范围的是长整型，long
方法：
int 将字符串转换为数字
a = "123"
print(type(a),a)
b = int(a)
print(type(b),b)
b = b + 1000
base=2# 将字符串以2进制的方式解读为10进制
num = "0011"
v = int(num,base=2) # 将字符串以2进制的方式解读为10进制
print(v)
bit_length 当前数字的二进制至少是几位。
age = 10
r = age.bit_length()
print(r)
# 字符串，str 所有的功能，都放在str里
# s1 = "alex"
# s2 = "root"
# s1.title()
# s1.startswith('xxx')
方法：
repitalize 首字母大写
test = "alex"
v = test.replace()
print(v)
lower 把字符变小写，限于英文
test = "alex"
v1 = test.lower()
print(v1)
casefold 把字符变小写，更全面
test = "alex"
v2 = test.casefold()
print(v2)
center (20,'*') 设置宽度，并将内容剧中
20 代指长度
* 空白位置填充（只能写一个字符）可以不写
test = "alex"
v = test.center(20,'*')
print(v)
ljust() 设置宽度，并将内容放在左边
test = "alex"
v = test.ljust(20, '*')
print(v)
rjust() 设置宽度，并将内容放在右边
test = "alex"
v = test.rjust(20, '*')
print(v)
count('e',5,10) 子序列在字符串中出现的次数
e 计算e在字符串中出现的次数
5 从第5个字符开始计算
10 到第10个字符结束
test = "alexexeddd"
v = test.count('e',5,10)
print(v)
endswith('ex',5,10) 判断在字符串中是否是以这个子序列结尾
5和10 开始和结束
test = "alex"
v = test.endswith('ex',5,10)
print(v)
startswith('a',5,10) 同endswith类似，判断在字符串中是否是以这个子序列开头
find('ex'，5，10) 从开始往后找，找到第一个后，获取其位置
'ex'为要查找的子序列，数字为起始和结束的位置
>取值范围>=
test = "alexalexalex"
v = test.find('ex')
print(v)
index() 和find()类似，区别在于index找不到，就报错
format(name = 'alex',age {a}) 格式化，将一个字符串中的占位符替换为指定的值
test = 'i am {name},age {a}'
print(test)
v = test.format(name = 'alex',a = 19)
print(v)
占位符可以用数字代替
test = 'i am {0},age {1}'
print(test)
v = test.format('alex', 19)
print(v)
format_map({"name":"alex","a":19}) 格式化，传入的值{"name":"alex","a":19}
test = 'i am {name},age {a}'
print(test)
v = test.format_map({"name":"alex","a":19})
print(v)
isalnum() 字符串中是否只包含字母和数字
test = "uasf890_+"
v = test.isalnum()
print(v)
isalpha() 字符串中是否只包含字母或汉字
test = "adfaf中"
v = test.isalpha()
print(v)
isdecimal() 判断输入的是否是数字
isdigit() 比isdecimal支持的更全面
isnumeric() 比isdigit更多的支持了中文的数字比如 二
test = "123a"
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1,v2,v3)
isidentifier() 判断一个字符串是否是由字母，数字，下划线组成且不能是以数字开头
a = "def"
v = a.isidentifier()
print(v)
islower() 判断字符串是否都是小写
a = "def"
v = a.islower()
print(v)
isprintable() 判断字符串中是否存在不可显示的字符# ...不存在是True
test = "oauefnafj
"
v = test.isprintable()
print(v)
isspace() 判断字符串中是否只存在不可显示的字符，只存在是True
test = "adf adf"
v = test.isspace()
print(v)
istitle() 判断是否是标题，既所有首字母大写，是 True
v1 = test.istitle()
print(v1)
v2 = test.title() # 将字符串内所有单词的首字母转换为大写
print(v2)
v3 = v2.istitle()
print(v3)
***join() 将字符串中的每一个元素按照指定分隔符进行拼接
test = "你是风儿我是沙"
print(test)
t = ' ' # or 'adfawe'
v = t.join(test)
print(v)
lower() 将字符串全部变为小写
test = "ALex"
v1 = test.islower() # 判断是否全部是小写
v = test.lower()
print(v)
v3 = test.isupper() # 判断是否全部是大写
v4 = test.upper() # 将字符串全部变为大写
print(v4)
strip() 去掉字符串两边的空格
lstrip() 默认去掉字符串左边的空格,和 ,如果指定内容，可以去掉指定内容,优先最多匹配
rstrip('le') 默认去掉字符串右边的空格,和 ，如果指定内容，可以去掉指定内容,优先最多匹配
test = " alex "
v = test.strip()
print(v)
maketrans() 创建两组字符串的对应关系
translate() 将有对应关系的两组字符串进行对应
v = "ouewzndjdasofjwen"
m = str.maketrans("aeiou","12345")
new_v = v.translate(m)
print(new_v)
partition() 左到右以匹配到的第一个关键字分割成三份,保留关键字
rpartition() 右到左以匹配到的第一个关键字分割成三份,保留关键字
test = "eoauwjadfapwefwoij"
v = test.partition('u')
print(u)
split() 左到右以匹配到的关键字分割成指定的份数,不保留关键字
rsplit() 右到左以匹配到的关键字分割成指定的份数,不保留关键字
test = "wefjwoejefjwoefj"
v = test.split('j',2)
print(v)
splitlines(True) 只能根据换行符 分割，true和false选择是否保留换行
test = "ajldfjaoj
jawoejfoj
wojfwf"
v = test.splitlines(True)
print(v)
startswith() 判断是否以指定子序列开头
endswith() 判断是否以指定子序列结尾
test = "afasd12312"
v = test.startswith('af')
print(v)
swapcase() 大小写互相转换
test = "aLeX"
v = test.swapcase()
print(v)
replace("ex","aaa",2) 子序列的替换，数字指定替换前几个
test = "alexealexalex"
v = test.replace("ex","aaa",2)
print(v)
********** 7个基本魔法 *************
join() 将字符串中的每一个元素按照指定分隔符进行拼接
split() 左到右以匹配到的关键字分割成指定的份数, 不保留关键字
find('ex'，5，10) 从开始往后找，找到第一个后，获取其位置'ex'为要查找的子序列，数字为起始和结束的位置
strip() 去掉字符串两边的空格
upper() 将字符串全部变为大写
lower 把字符变小写，限于英文
replace("ex","aaa",2) 子序列的替换，数字指定替换前几个
** ** ** ** ** 4个灰魔法 ** ** ** ** ** ** *
#通过索引，下标获取字符串中的某一个字符
test = "alex"
v = test[0]
print(v) # 结果是a，0是a的下标
# 切片
v = test[0:2] # 范围取值<=0 <1 指定复数从后往前数
print(v)
# len python3中：计算字符串中共有多少个字符。python2中计算字符串中共有多少个字节
test = "中中在"
v = len(test)
print(v)
# >>>
test = "妹子有种冲我来。"
index = 0
while index > len(test):
v = test[index]
print(v)
index += 1
print("=======")
# for 循环
for 变量名 in 字符串：
变量名
test = "妹子有种冲我来。"
for mz in test:
print(mz)
# <<<
test = "妹子有种冲我来。" #for 循环也支持continue和break
for item in test:
continue
print(item)
range(0,100,5) 创建连续的数字或不连续的数字，通过设置步长：5
v = range(0,100,5)
for item in v:
print(item)
v = range(100,0,-1)
for i in v:
print(i)
练习：将文字对应的索引打印出来
test = input("...")
v = len(test)
v2 = range(0,v)
for item in v2:
print(item,test[item])
# 简写：
test = input("...")
for item in range(0,len(test)):
print(item,test[item])
灰魔法里几乎所有的方法在其他数据类型里也能用
主要先记住上面十个魔法
** ** ** ** ** 1个灰魔法 ** ** ** ** ** ** *
字符串一旦创建就不可修改
一旦修改或则拼接，都会造成重新生成字符串
列表是有序的，元素可以被修改
#####################灰魔法，list类中提供的方法##########################
对象.方法（） # 对象调用方法
append(5) #在原值最后追加
li = [11,22,33,44]
li.append(5)
li.append("alex")
li.append([1234.1212])
print(li)
clear # 清空列表
li.clear(li)
print(li)
copy # 拷贝，浅拷贝
v = li.copy()
print(v)
count # 计算元素出现的次数
li = [11,22,33,22,44]
v = li.count(22)
print(v)
extend # 扩展原来的列表,参数：可迭代对象
li = [11, 22, 33, 22, 44]
li.append([9898,"xxx"])
[11, 22, 33, 22, 44, [9898, 'xxx']]
li.extend([9898,"xxx"])
[11, 22, 33, 22, 44, 9898, 'xxx']
li.extend("xxx")
[11, 22, 33, 22, 44, 'x', 'x', 'x']
print(li)
index(33) # 根据值获取当前值索引位置，左边优先
li = [11, 22, 33, 22, 44]
v = li.index(33)
print(v)
insert(0,99) #在指定索引位置插入元素，0位置插入99
li = [11, 22, 33, 22, 44]
li.insert(0,99)
print(li)
pop(1) # 删除某个值，并获取删除的值，默认删除最后一个，或者指定索引
li = [11, 22, 33, 22, 44]
v = li.pop(1)
print(li)
print(v)
remove(33) #删除列表中的指定值，左边优先
li = [11, 22, 33, 22, 44]
li.remove(33)
print(li)
ps 删除的方法: pop remove del li[0] del[0:9] clear
reverse() # 将当前列表进行反转
li = [11, 22, 33, 22, 44]
li.reverse()
print(li)
sort # 排序
li = [11, 22, 33, 22, 44]
li.sort() # 从小到大排序
li.sort(reverse=True) # 从大到小排序
print(li)
#################################深灰魔法##################################
列表的基本格式：
li = [["xxx","aaa"],1,12,9,"age","alex"] # 通过list类创建的对象，li
中括号括起来
，号分割每个元素
列表中的元素可以是，数字，字符串,列表，布尔值所有的都能放进去
“集合”，内部能放置任何东西
print(li[3]) # 索引取值
print(li[3:5]) # 切片取值，列表
for循环
while循环
列表元素可以被修改
li[1] = 120
li[2] = [11,22,33]
li[1:3] = [120,90] # 切片的方式修改
删除
del li[1]
del li[2:6] # 切片的方式删除
in 操作
v = 12 in li
print(v)
列表中的每一个元素都是一个整体
查找列表内的列表
li = [["xxx","aaa"],1,12,9,"age","alex"]
li = [4][0][1]
list()把字符串转换成列表,内部使用for循环 ，数字不可以
s = "sjflajflasdhfalsdfj"
new_li = list(s)
print(new_li)
# ['s', 'j', 'f', 'l', 'a', 'j', 'f', 'l', 'a', 's', 'd', 'h', 'f', 'a', 'l', 's', 'd', 'f', 'j']
列表转换成字符串：
1，需要for循环逐个处理,既有数字又有字符串
s = ''
for i in li:
s = s + str(i)
print(s)
2，只有字符串
v = "".join(li)
print(v)
#列表
li = [11,22,33,44]
元祖和列表都是有序的
# 元祖,tuple 。。。
元素的一级元素不可被修改，不能被增加或删除
书写格式
tu = (11,22,33,44,"alex",)
一般写元祖的时候,在最后多加个，号，为了和参数区分
####################灰魔法：方法:###########################
count(22) # 获取指定元素在元祖中出现的次数
count(22) # 获取指定元素在元祖中出现的次数
tu = (11, 22, 33, 44, "alex",)
v = tu.count(22)
print(v)
index(22,0,5) # 获取某个指定值的索引，左边优先
tu = (11, 22, 33, 44, "alex",)
v = tu.index(22,0,5)
print(v)
####################深灰魔法#################################
索引取值
v = tu[0]
print(v)
切片
v = tu[0:2]
print(v)
可以被for循环，可迭代对象
for item in tu:
print(item)
转换
s = 'jajdfljaldjfljaf'
v = tuple(s)
print(v)
li = [11,22,33]
v2 = tuple(li)
print(v2)
tu = (123,"ajfo",)
li = list(tu)
print(li)
只有字符串的时候,可以动过join连接
tu = ("werwr","jsjdlfa",)
v = _".join(tu)
print(v)
获取
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
v = tu[3][0][0]
print(v) # 获取到值 33
元祖的一级元素不可修改，不能被增加或删除
但元祖内的列表可以修改,列表内的元祖不可以
tu = (111, "alex", (11, 22), [(33, 44)], True, 33, 44,)
tu[3][0] = 66
print(tu)
# 字典,dict 。。。
######################方法：#############################
fromkeys(["k1","123","999"],123) #根据序列，创建字典，并指定统一的值
v = dic.fromkeys(["k1","123","999"],123)
print(v)
get('k1222',22222) # 根据key获取值，可以指定key不存在时显示的内容 22222 默认值None
dic = {"k1":'v2'}
v = dic.get('k1222',22222)
print(v)
pop('k1',90) # 删除指定的值并获取删除的值，可以指定key不存在时返回的值 90
dic = {"k1": 'v2'}
v = dic.pop('k1',90)
print(dic,v)
popitem() #删除并获取键值对
dic = {"k1": 'v2',"k2":'v3'}
k,v = dic.popitem()
print(dic,k,v)
setdefault('k111','123') # 设置值，已经存在则不设置，获取当前值，不存在则设置型键值对，获取新值
dic = {"k1": 'v2', "k2": 'v3'}
v = dic.setdefault('k111','123')
print(dic,v)
update({'k1':'111111','k3':123}) # 更新
dic = {"k1": 'v2', "k2": 'v3'}
dic.update({'k1':'111111','k3':123})
print(dic)
dic.update(k1=123,k3=345,k5='dsfa')
print(dic)
#keys() values() items() get() update() # 重要
书写格式
info = {"k1":"v1","k2":"v2"} # "k1":"v1" 键值对，一个键一个值
指点的value可以是任何值
info = {
"k1":18,
"k2":True,
"k3":[
11,33,44,{
"kk1":'vv1',
"kk2":'vv2',
"kk3":(11,22)
}
],
"k4":(11,22,33,44)
}
print(info)
字典无序
列表不能做为字典的key
字典不能做为字典的key
布尔值注意不要和其他的键0或1重复
info = {
1:'adf',
"k1":'adf',
False:"123",
[11,22]:123, #列表不能做为字典的key
(11,22):123,
{'k1':'v1'}:123 # 字典不能做为字典的key
}
取值
索引方式找到指定元素
info = {
"k1":18,
2:True,
"k3":[
11,33,44,{
"kk1":'vv1',
"kk2":'vv2',
"kk3":(11,22)
}
],
"k4":(11,22,33,44)
}
v = info['k1']
print(v)
v = info['k3'][3]['kk3'][0]
print(v) # 获取 11
删除的方法
del
del info["k3"][3]['kk1']
for循环
for item in info:
print(item) # 默认for循环只有key
for item in info.keys():
print(item) # 显示key
for item in info.values():
print(item) # 显示values
for item in info.keys():
print(item,info[item]) # 显示键和值
for k,v in info.items():
print(k,v) # 显示键和值
#
# 布尔,bool 。。。
None '' () {} [] 0 布尔值判断时都是False
# 布尔类型： true真 和 false假
# 判断语句的和in not in 和比较的结果都是布尔值