整理python3常用的int，str、list、tuple、dict，range函数
一、int：转成数字
i="123"
j=int(i)
print(j,type(i),type(j))
#123 <class 'str'> <class 'int'>
（1）整数：加（+），减（-），乘（*），除（/），次方（**），a=39%2：取余数，a=39//4：获取到商（为4）；还可以使用括号来修改运算次序。
1.字符串与数字的转换以及确定相应的数据类型使用type()
|
1
2
3
4
5
6
7
8
9
|
a="123"b=int(a)print(b)print(type(a))print(type(b))#结果为：123<class 'str'><class 'int'> |
使用2、8、10、16进制（2可以换成8和16，默认是10进制）
|
1
2
3
4
|
a="101101"i=int(a,base=2)print(i)#结果：45 |
2. bit_length(self)
该数字的二进制至少有几位表示（首位是0会取消掉）
|
1
2
3
4
|
a=45i=a.bit_length()print(i)#结果：6 |
3.conjugate(self, *args, **kwargs)
返回该复数的共轭复数
|
1
2
3
4
|
a=45i=a.conjugate()print(i)#45 |
4.from_bytes(cls, bytes, byteorder, *args, **kwargs)
返回给定的字节数组表示的整数。
5.to_bytes(self, length, byteorder, *args, **kwargs)
返回表示整数的字节数组。
6.__abs__(self, *args, **kwargs)
返回绝对值
|
1
2
3
4
|
a=-45i=a.__abs__()print(i)#45 |
7.__add__(self, *args, **kwargs)
相加
|
1
2
3
4
|
a=45i=a.__add__(55)print(i)#100 |
8.__and__(self, *args, **kwargs)
返回自身和传入的值
9.__bool__(self, *args, **kwargs)
判断是不是0（等于0，返回false，不等于0，返回true）
10.__ceil__(self, *args, **kwargs)
积分的上限返回自身。
11.__divmod__(self, *args, **kwargs)
返回divmod（自我，价值）
12.__eq__(self, *args, **kwargs)
判断两个值是否相等（相等，返回true，不相等，返回false）
13.__float__(self, *args, **kwargs)
返回float类型
14.__floordiv__(self, *args, **kwargs)
获取到商
15.__floor__(self, *args, **kwargs)
地板积分返回自身。（实在是不懂是什么意思咯，谷歌翻译）
二、字符串
（字符串一旦创建，不可修改
一旦修改或者拼接，都会造成重新生成字符串）
字符串：表示方式有四种：n=" "，n=' '， n=''' ''',n=""" """
（1）修改字符串的大小写
message='wesshws asdwdj fdgbghs dhasjd shhhc'
print(message.title())
##############
Wesshws Asdwdj Fdgbghs Dhasjd Shhhc
endswith
startwith
# 以什么什么结尾
# 以什么什么开始
# test = "alex"
# v = test.endswith('ex')
# v = test.startswith('ex')
# print(v)
find
# 7 从开始往后找，找到第一个之后，获取其未知
# > 或 >=
# test = "alexalex"
# 未找到 -1
# v = test.find('ex')
# print(v)
# 8 index找不到，报错 忽略
# test = "alexalex"
# v = test.index('8')
# print(v)
format
（1）用{}来占坑
（2）%s 占坑字符串【这个可以填任何数据】，%d占坑数字，%f占坑浮点数【%.2f——>保留两位小数，做四舍五入】
# 9 格式化，将一个字符串中的占位符替换为指定的值
# 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)
# 10 格式化，传入的值 {"name": 'alex', "a": 19}
# test = 'i am {name}, age {a}'
# v1 = test.format(name='df',a=10)
# v2 = test.format_map({"name": 'alex', "a": 19})
join
# 17 ***** 将字符串中的每一个元素按照指定分隔符进行拼接
# test = "你是风儿我是沙"
# print(test)
# v = "_".join(test)
# print(v)
upper，lower
# 18 判断是否全部是大小写 和 转换为大小写
# test = "Alex"
# v1 = test.islower()
# v2 = test.lower()
# print(v1, v2)
# v1 = test.isupper()
# v2 = test.upper()
# print(v1,v2)
strip
移除指定字符串
# 有限最多匹配
# test = "xa"
# # v = test.lstrip('xa')
# v = test.rstrip('9lexxexa')
# # v = test.strip('xa')
# print(v)
# test.lstrip()
# test.rstrip()
# test.strip()
# 去除左右空白
# v = test.lstrip()
# v = test.rstrip()
# v = test.strip()
# print(v)
# print(test)
# 去除\t \n
# v = test.lstrip()
# v = test.rstrip()
# v = test.strip()
# print(v)
split
字符串名.split(切割符号,切割次数)，默认为全部，返回的数据类型是一个列表，并且列表里面的子元素都是字符串类型；
指定的切割符，被切走了；
s='hellopytlllhon'
print(s.split('l',2))
#############
['he', '', 'opytlllhon']
# 21 分割为三部分
# test = "testasdsddfg"
# v = test.partition('s')
# print(v)
# v = test.rpartition('s')
# print(v)
# 22 分割为指定个数
# v = test.split('s',2)
# print(v)
# test.rsplit()
# 23 分割，只能根据，true，false：是否保留换行
# test = "asdfadfasdf\nasdfasdf\nadfasdf"
# v = test.splitlines(False)
# print(v)
replace
字符串.replace('旧值','新值',替换次数)，默认次数为全部
# 27 将指定字符串替换为指定字符串
# test = "alexalexalex"
# v = test.replace("ex",'bbb')
# print(v)
# v = test.replace("ex",'bbb',2)
# print(v)
for循环
# 一、for循环
# for 变量名 in 字符串:
# 变量名
# break
# continue
# index = 0
# while index < len(test):
# v = test[index]
# print(v)
#
# index += 1
# print('=======')
# for zjw in test:
# print(zjw)
# test = "乌克兰小乳猪"
# for item in test:
# print(item)
# break
# for item in test:
# continue
# print(item)
字符串取值：【很重要】
单个取元素：
字符串名[索引值]
索引值从0开始；
正序取元素；反序取值；
例如：hellopython
正序：0，1，2，3，4，5，6，7，8，9
反序：-1，-2。。。。-9
取多个元素：
字符串名[索引头：索引尾：步长]，默认步长为1，并且规则是取头不取尾
例如;
s='hellopython'
s[1:5:2]#1 3——>el
s[:]——>全取
索引
# 二、索引，下标，获取字符串中的某一个字符
# v = test[3]
# print(v)
切片
# 三、切片
# v = test[0:-1] # 0=< <1
# print(v)
len
# 四、获取长度
# Python3： len获取当前字符串中由几个字符组成
# v = len(test)
# print(v)
range
# 五、获取连续或不连续的数字，
# Python2中直接创建在内容中
# python3中只有for循环时，才一个一个创建
# r1 = range(10)
# r2 = range(1,10)
# r3 = range(1,10,2)
# 帮助创建连续的数字,通过设置步长来指定不连续
# v = range(0, 100, 5)
#
# for item in v:
# print(item)
三、列表
（有序的；
中括号括起来[];
逗号分隔；
列表中的元素可以是数字、字符串、列表，布尔值，元祖，字典；
列表内的元素，可以是其它任意类型的数据，可多层嵌套列表，元素个数无限制；
可被修改）
max[list]————返回列表元素的最大值
min[list]————返回列表元素的最小值
但是不能混合不同类型求最大值最小值；
list[seq]————将序列转换为列表【说实话，不是很懂】
（1）添加元素
append([])——————————————在列表的末尾添加元素，只能追加一个元素每次。
可不新的变量保存，原来的值最后追加
li=[123,22,"asd","q",34]
li.append(100)
print(li)
#结果：[123, 22, 'asd', 'q', 34, 100]
extend
li=[123,22,"asd","q",34]
li.extend([12,333,45,"asd"])
print(li)
#结果：[123, 22, 'asd', 'q', 34, 12, 333, 45, 'asd']
li=[123,22,"asd","q",34]
li.extend(1000)
print(li)
#结果：TypeError: 'int' object is not iterable
区别：extend与append方法的相似之处在于都是将新接收到参数放置到已有列表的后面。而extend方法只能接收list，且把这个list中的每个元素添加到原list中。
而append方法可以接收任意数据类型的参数，并且简单地追加到list尾部。
i=[1,2,3,4]
i.extend(["a","b"])
print(i)
i1=[1,2,3]
i1.append(["a","b"])
print(i1)
i2=[123,456]
i2.append(0)
print(i2)
i3=[1,2]
i3.extend("abc")
print(i3)
######################
[1, 2, 3, 4, 'a', 'b']
[1, 2, 3, ['a', 'b']]
[123, 456, 0]
[1, 2, 'a', 'b', 'c']
insert）-----——————————可以在列表的任何位置添加元素，要指定元素的索引值。
（第一个参数是下标，第二个参数是value）
li=[123,22,"asd","q",34]
li.insert(0,200000)
print(li)
#结果：[200000, 123, 22, 'asd', 'q', 34]
（2）删除元素
del 列表名[索引值]————前提知道要删除元素在列表中的索引，并且无法再访问了；
pop（）————删除末尾的元素，并且能够接着使用它；会返回被删除的那个元素。
pop（索引值）————删除索引所在的元素，并且能够接着使用它，会返回被删除的那个元素；
remove（" "）————————根据值删除元素，并且也是可接着使用它的值，会返回被删除的那个元素。
message=[4,'sd','fhr',78,'dgh',45,515,99999,'sb','sbb','sbbb']
del message[-2]
print(message)
message1=message.pop()
print(message)
print(message1)
message2=message.pop(0)
print(message2)
message3=message.remove('sb')
print(message)
######################
[4, 'sd', 'fhr', 78, 'dgh', 45, 515, 99999, 'sb', 'sbbb']
[4, 'sd', 'fhr', 78, 'dgh', 45, 515, 99999, 'sb']
sbbb
4
['sd', 'fhr', 78, 'dgh', 45, 515, 99999]
（3）排序
sort()
sort(reverse=True) ———————相反的顺序排序
该两种方法对列表的修改是永久性的
message=[1,23,45,25,12,69,55]
message1=["sd","rf","asg"]
message.sort()
message1.sort()
print(message,message1)
#############################
[1, 12, 23, 25, 45, 55, 69] ['asg', 'rf', 'sd']
message=[1,23,45,25,12,69,55]
message1=["sd","rf","asg"]
message.sort(reverse=True)
message1.sort(reverse=True)
print(message,message1)
#########################
[69, 55, 45, 25, 23, 12, 1] ['sd', 'rf', 'asg']
临时排序——sorted（），sorted(reverse=True)
message=[1,23,45,25,12,69,0,55]
message1=["sd","asg","rf","ws","ca"]
message2=sorted(message)
message3=sorted(message1,reverse=True)
print(message,message1)
print(message2,message3)
#########################
[1, 23, 45, 25, 12, 69, 0, 55] ['sd', 'asg', 'rf', 'ws', 'ca']
[0, 1, 12, 23, 25, 45, 55, 69] ['ws', 'sd', 'rf', 'ca', 'asg']
(4)倒着打印列表和确定列表的长度【很重要】
message=[1,23,45,25,12,69,0,55]
message1=["sd","asg","rf","ws","ca"]
message.reverse()
print(message)
print(len(message1))
######################
[55, 0, 69, 12, 25, 45, 23, 1]
5
（5）使用range()创建数字列表
range()函数可以生成一系列的数字，还可以指定步长
使用list()吧range()结果转为列表；
int1=range(1,6)
for i in int1:
print(i)
int2=range(0,50,5)
for i1 in int2:
print(i1)
message=list(int2)
for i3 in message:
print(i3)
对数字列表进行简单的统计计算：
number=[0,23,43,55,65,43,96]
print(min(number))
print(max(number))
print(sum(number))
##########################
0
96
325
索引
li=[123,22,"asd","q",34]
i=li[0]
print(i)
#结果：123
切片——到达指定的第二个索引前面的元素后停止
列表名[x,y](x,y道标索引值)
如果没有制定第一个索引值，则自动从列表开头开始。
li=[123,22,"asd","q",34]
i=li[0:-1]
print(i)
#结果：[123, 22, 'asd', 'q']
循环——在for循环后面没有缩进的代码都只执行一次，并且不会重复执行。
li = [123, 22, "asd", "q", 34]
for item in li:
print(item)
#结果：
123
22
asd
q
34
四.元组（tuple）
（用圆括号来标识
有序的；
元素不可以被修改，增加，删除；
元组只保证它的一级子元素不可变，对于嵌套的元素内部，不保证不可变！
比如如果元组里面有列表，那就可以修改列表里面的元素进行修改。
一般在写元祖的时候，推荐在后面输入，（英文逗号）
元祖的一级元素不可以被修改、删除、增加；但是可以给存储元祖的变量赋值；
元组里面可以是任何的数据；
所以，在使用元组的时候，请尽量使用数字、字符串和元组这种不可变的数据类型作为元组的元素，这样就能确保元组不发生变化。
逗号分隔；
但是如果元祖只有一个元素时候，后面要加上逗号，a=("hello")——>类型是字符串；
元组使用切片取值也一样的道理。
number=(200,999)
print(number)
number=(300,"sb")
print(number)
#####################
(200, 999)
(300, 'sb')
索引、切片、循环
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串；返回通过指定字符连接序列中元素后生成的新字符串
拼接分为：只有字符串：“”.join()
有字符串和数字：只有自己写for循环
tu = (123, 23, "qwe", "asd", 44)
tu1 = (124, 34, "qas")
tu2 = tu + tu1
for item in tu2:
print(tu2)
#结果：
(123, 23, 'qwe', 'asd', 44, 124, 34, 'qas')
(123, 23, 'qwe', 'asd', 44, 124, 34, 'qas')
(123, 23, 'qwe', 'asd', 44, 124, 34, 'qas')
(123, 23, 'qwe', 'asd', 44, 124, 34, 'qas')
(123, 23, 'qwe', 'asd', 44, 124, 34, 'qas')
(123, 23, 'qwe', 'asd', 44, 124, 34, 'qas')
(123, 23, 'qwe', 'asd', 44, 124, 34, 'qas')
(123, 23, 'qwe', 'asd', 44, 124, 34, 'qas')
tu1 = ("bn", "qas")
tu2 = "*".join(tu1)
print(tu2)
#结果：bn*qas
五、字典
（键-值对；
{}花括号表示；
逗号隔开；
从Python3.6开始，字典是有序的！它将保持元素插入时的先后顺序！请务必清楚。
一个对象能不能作为字典的key，就取决于其有没有__hash__方法。字典包含的元素个数不限，值的类型可以是任何数据类型！但是字典的key必须是不可变的对象，例如整数、字符串、bytes和元组，最常见的还是将字符串作为key。列表、字典、集合等就不可以作为key。同时，同一个字典内的key必须是唯一的，但值则不必。所以所有python自带类型中，目前已知的除了list、dict、set和内部带有以上三种类型的tuple之外，其余的对象都能当key。布尔值也是可以的，只是在其存在计算机中是0和1存储，所以要区分其和数字0,1；
value可以包含任何类型的数据。
）
（1）
字典是一种动态结构，可随时在其中添加键值对。
添加键-值对
已存在的key就是修改，不存在的key就是新增；
persen={'name':'alice','age':'18','sex':'man'}
persen['hobby']='games'
print(persen)
######################
{'sex': 'man', 'name': 'alice', 'hobby': 'games', 'age': '18'}
（2）修改字典中的值
persen={'name':'alice','age':'18','sex':'man','hobby':'games'}
persen['age']='20'
print(persen)
###################
{'name': 'alice', 'hobby': 'games', 'sex': 'man', 'age': '20'}
（3）删除键-值对
字典名.pop('指定要删除的key值')
使用del要指定字点明和删除的键
persen={'name':'alice','age':'18','sex':'man','hobby':'games'}
del persen['hobby']
print(persen)
#####################
{'sex': 'man', 'name': 'alice', 'age': '18'}
（4）遍历所有的键-值对———————————需要使用到items（）方法
persen={'name':'alice','age':'18','sex':'man','hobby':'games'}
for x,y in persen.items():
print(x+':'+y)
########################
name:alice
sex:man
age:18
hobby:games
（5）遍历字典中的所有键
keys()
获取key值
dic={"1":"qw","23":"wed","c":"(78,39,95)"}
dic.keys()
for item in dic:
print(item)
#结果：
1
23
c
（6）遍历字典中的所有值
values
获取value值
dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print ("字典所有值为 : ", list(dict.values()))
#结果：
字典所有值为 : ['female', 7, 'Zara']
（7）遍历所有的键-值对
item（）
dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print ("字典所有值为 : ", list(dict.items()))
#结果：字典所有值为 : [('Name', 'Zara'), ('Age', 7), ('Sex', 'female')]
（8）
get
Python 字典 get() 函数返回指定键的值，如果值不在字典中返回默认值
返回指定键的值，如果值不在字典中返回默认值 None。
dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print ("结果是：",dict.get("Age"))
#结果是： 7
（9）set（）获取独一无二的值
dic={"1":"qw","23":"wed","3":"qqw","582":"(78,39,95)","3":"qw","62":"dgsh"}
for item in set(dic.keys()):
print(item)
print('华丽分割线--- --- --- --- ---- --- ----')
for item1 in set(dic.values()):
print(item1)
###############################
62
3
1
582
23
华丽分割线--- --- --- --- ---- --- ----
wed
dgsh
(78,39,95)
qw
Python3 字典 update() 方法
Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
添加到指定字典dict里的字典。
dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
dict2 = {"qw": "123", "a": "67"}
dict.update(dict2)
print("结果是：", dict)
#结果是： {'qw': '123', 'Age': 7, 'Sex': 'female', 'Name': 'Zara', 'a': '67'}
索引、切片、循环
六、（简单补充）
在bool里面，返回为false的有如下：
None，“”，(),[],0;
其余的返回都为真。
3.基本数据类型
数字和字符串
（1）数值运算：加、减、乘、除、幂、取余、取商
in-------------------判断某个东西是否在某个东西里面包含
not-----------------------反之
字符串的子序列：“编辑问”的子序列：“编辑问”、“编辑”、“辑问”、“编”、“辑”、“问”
（2）布尔值：True和Flase
（3）逻辑运算：and、or
先计算括号里面的，执行顺序：顺序执行
true or----------------结束，结果为true
true and--------------继续走
false and------------flase
false or------------------继续走
【任性插入求模运算符（%）】————————它将指出余数是多少
如果一个数可被另外一个数整除，余数就是0，由此可以使用来判断一个数是奇数还是偶数。
| * | 重复输出字符串，相当于乘法 | a * 2 | 'HelloHello' |
浙公网安备 33010602011771号