2、数字，字符串，列表，字典，集合

本节主要内容

运算符

数值运算

字符串

列表

字典

集合

 

一、运算符

算数运算：

比较运算：

赋值运算：

逻辑运算：

成员运算：

身份运算：

位运算：

补码详解 

http://blog.csdn.net/wenxinwukui234/article/details/42119265 

运算符优先级：

参考

http://www.runoob.com/python/python-operators.html

 

二、数值运算

数值运算操作符

1，+ - * %(整除)

2，/ 表示商，10/3的结果是3.3333333

3，// 表示整数商，10/3的结果是3

4，** 表示幂运算，如果a**b ，b是小数，那么表示开方

数值运算函数

1，abs(x) 求x的绝对值

2，divmod(x,y) 相当于%，divmod(10,3)结果是（3,1）也就是商3余1

3，pow(x,y[,z]) 函数表示x的y次方，如果由参数z则表示x的y次方，然后用x进行模运算之后的余数，即幂余函数，这是为了防止x,的y次幂太大导致计算机无法工作，而经常需要的

只是后几位而已

4，round(x[,d])表示对x进行四舍五入，精度默认为0

5，max()判断参数中的最大值

6，min()判断参数中的最小值

7，int(x) 取证函数，把参数，不论是小数，还是字符串都可以，转换成整数

8，float(x)函数，可以把参数转换成浮点数，如果是整数的话，则设置小数点后一位为0，如果是字符串则直接转换为浮点数

9，complex(x)函数，把x转换为实数部分，增加虚数部分，默认是0j

参考

https://blog.csdn.net/u013894427/article/details/80261206

 

三、字符串操作

python中字符串是不可变对象，所以所有修改和生成字符串的操作的实现方法都是另一个内存片段中新生成一个字符串对象。例如，'abc'.upper()将会在划分另一个内存片段，并将返回的ABC保存在此内存中。

参考

https://www.jb51.net/article/141376.htm

1、capitalize() 首字母大写

2、casefold() 大写全部变小写

3、center()

1 >>> name = 'matt'
2 >>> name.center(50,'-')
3 '-----------------------matt-----------------------'

4、count('a') 统计 a出现次数

5、encode() 将字符串编码成bytes格式

6、endswith("Li") 判断字符串是否以 Li结尾

7、expandtabs()   将字符串S中的\t替换为一定数量的空格。默认N=8。

注意，expandtabs(8)不是将\t直接替换为8个空格。例如'xyz\tab'.expandtabs()会将\t替换为5个空格，因为"xyz"占用了3个字符位。

1 >>> 'zt\tmatt'.expandtabs(10)
2 'zt        matt'

8、find('A')   查找A,找到返回其索引， 找不到返回-1

9、format ，三种格式

1 >>> 'my name is {}, and i am {}'.format('zt',22)
2 'my name is zt, and i am 22'
3 >>> 'my name is {1}, and i am {0}'.format('zt',22)
4 'my name is 22, and i am zt'
5 >>> 'my name is{name}, and i am {age}'.format(name = 'zt',age =22)
6 'my name iszt, and i am 22'

10、format_map    #以字典的形式赋值

1 >>> 'my name is {name}, and i am {age}'.format_map({'name': 'zt','age':22})
2 'my name is zt, and i am 22'

11、index('a') 返回a所在字符串的索引（找不到事提示错误），与msg.find()区别（找不到时返回-1）

12、isalnum() 判断字符变量是否为字母或数字

1 >>> 'a8Yn9'.isalnum()
2 True

13、isdigit()  判断是否整数

1 >>> '8.35'.isdigit()
2 False

14、isnumeric()   检测字符串是否只由数字组成，如果字符串中只包括数字，就返回Ture，否则返回False

15、isprintable() 

16、isspace()  检测字符串是否只由空白字符组成

17、istitle()     是否为标题

18、isupper() 所有字母是否为大写

19、join     #字符串拼接

1 >>> '|'.join(['a','b','c'])
2 'a|b|c'

20、maketrans 与 translate       str.maketrans()生成一个字符一 一映射的table，然后使用translate(table)对字符串S中的每个字符进行映射。

1 >>> str_in = 'abcxyz'
2 >>> str_out = '123456'
3 >>> transtab = str.maketrans(str_in,str_out)
4 >>> 'i am matt'.translate(transtab)
5 'i 1m m1tt'

maketrans 和translate是联合起来用的，加密的作用

21、partition() 与rpartition()

S.parttition(seq)  ,S.rpartiton()

搜索字符串S中的子串sep，并从sep处对S进行分割，最后返回一个包含3元素的元组：sep左边的部分是元组的第一个元素，sep自身是元组的二个元素，sep右边是元组的第三个元素。partition(sep)从左边第一个sep进行分割，rpartition(sep)从右边第一个sep进行分割。如果搜索不到sep，则返回的3元素元组中，有两个元素为空。partition()是后两个元素为空，rpartition()是前两个元素为空。

1 >>> 'abcandxyz'.partition('and')
2 ('abc', 'and', 'xyz')

22、split()

S.split(sep=None, maxsplit=-1)

split()根据sep对S进行分割，maxsplit用于指定分割次数，如果不指定maxsplit或者给定值为"-1"，则会从做向右搜索并且每遇到sep一次就分割直到搜索完字符串。

1 >>> 'a,b,c,d'.split(',',2)
2 ['a', 'b', 'c,d']

spilt用途参考

https://blog.csdn.net/seetheworld518/article/details/47346527

23、splitlines()

splitlines()用来专门用来分割换行符。虽然它有点像split('\n')或split('\r\n')，但它们有些区别。

参考

https://www.jb51.net/article/141376.htm

 24、replace()

S.replace(old, new[, count])

将字符串中的子串old替换为new字符串，如果给定count，则表示只替换前count个old子串。如果S中搜索不到子串old，则无法替换，直接返回字符串S(不创建新字符串对象)。

1 >>> 'abcandabc'.replace('abc','matt')
2 'mattandmatt'

25、swapcase ()  大小写互换

1 >>> 'abcandABC'.swapcase()
2 'ABCANDabc'

26、zfill()  #以0填充

S.zfill(width)

用0填充在字符串S的左边使其长度为width。如果S前右正负号+/-，则0填充在这两个符号的后面，且符号也算入长度。

1 >>> 'aa'.zfill(5)
2 '000aa'
3 >>> '-aa'.zfill(5)
4 '-00aa'

27、ljust() 与rjust()

S.ljust(width[, fillchar])
S.rjust(width[, fillchar])

ljust()使用fillchar填充在字符串S的右边，使得整体长度为width。rjust()则是填充在左边。如果不指定fillchar，则默认使用空格填充。

1 >>> 'aa'.ljust(10,'-')
2 'aa--------'

28、isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
29、strip()

str.strip([char])

用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

>>> '  a a   '.strip()
'a a'
>>> '--a-a--'.strip('-')
'a-a'

 30、 str.upper() 

把所有字符中的小写字母转换成大写字母

 31、str.lower()

把所有字符中的大写字母转换成小写字母

列表

通过索引访问列表中的值

增 append()

1 >>> name = ['matt', 'jordan', 'logan', 'summer']
2 >>> name.append('tony')
3 >>> name
4 ['matt', 'jordan', 'logan', 'summer', 'tony']

 

切片

name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
print(name[0:3])
print(name[:3])
print(name[2:-1])
print(name[2:])
print(name[-2:-1])
print(name[::3])#每3个元素取一个

['matt', 'jordan', 'logan']
['matt', 'jordan', 'logan']
['logan', 'summer', 'linda']
['logan', 'summer', 'linda', 'amy']
['linda']
['matt', 'summer']

 

insert   插入

>>> name.insert(1 ,'jump')
>>> name
['matt', 'jump', 'jordan', 'logan', 'summer', 'linda', 'amy']

 

 改

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> name[2] = 'mike'
>>> name
['matt', 'jordan', 'mike', 'summer', 'linda', 'amy']

 

删除 del, remove, pop

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> del name[2]
>>> name
['matt', 'jordan', 'summer', 'linda', 'amy']

 

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> name.remove('matt')
>>> name
['jordan', 'logan', 'summer', 'linda', 'amy']

 

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> name.pop()
'amy'
>>> name.pop()
'linda'
>>> name
['matt', 'jordan', 'logan', 'summer']

 

extend 扩展

['matt', 'jordan', 'logan', 'summer']
>>> name = ['matt', 'jordan', 'logan']
>>> names = ['summer', 'linda', 'amy']
>>> name.extend(names)
>>> name
['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']

 

 cont 计数

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy', 'amy']
>>> name.count('amy')
2

 

 index  索引

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy']
>>> name.index('logan')
2

 sort 排序

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy',1,2,3]
>>> name.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'

 

>>> name = ['matt', 'jordan', 'logan', 'summer', 'linda', 'amy','1','2','3']
>>> name.sort()
>>> name
['1', '2', '3', 'amy', 'jordan', 'linda', 'logan', 'matt', 'summer']

>>> name.reverse()
>>> name
['summer', 'matt', 'logan', 'linda', 'jordan', 'amy', '3', '2', '1']

 

赋值，浅copy，深copy

赋值（只是生产连接），浅copy（表层copy，下一层生成连接）和深copy

import copy
name = ['matt', 'jordan', 'logan', 'summer',['linda', 'amy'] ]
name1 = name
name2 = name.copy()
name3 = copy.copy(name)
name4 = copy.deepcopy(name)
name[0] = 'MATT'
name[4][0] = 'LINDA'
print(name1)
print(name2)
print(name3)
print(name4)

 

列表操作包含以下函数:

1、cmp(list1, list2)：比较两个列表的元素 

2、len(list)：列表元素个数 

3、max(list)：返回列表元素最大值 

4、min(list)：返回列表元素最小值 

5、list(seq)：将元组转换为列表 

列表操作包含以下方法:

1、list.append(obj)：在列表末尾添加新的对象

2、list.count(obj)：统计某个元素在列表中出现的次数

3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

4、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置

5、list.insert(index, obj)：将对象插入列表

6、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

7、list.remove(obj)：移除列表中某个值的第一个匹配项

8、list.reverse()：反向列表中元素

9、list.sort([func])：对原列表进行排序

列表操作符

>>> [1,2]+[3,4]
[1, 2, 3, 4]

>>> ['a']*3
['a', 'a', 'a']

 

 

元组

元组可以称为只读列表，只有count()和index()两个方法

name = ('matt', 'jordan', 'logan', 'summer', 'linda', 'amy','amy')
print(name.count('amy'))
print(name.index('amy'))

字典

字典是无序的，所以先天排除重,dictionary

key: value

info = {'name': 'matt','age':'23', 'salary':'10000' }

增

info = {'name': 'matt','age':'23', 'salary':'10000' }
info['job'] = 'it'
print(info)

{'name': 'matt', 'age': '23', 'salary': '10000', 'job': 'it'}

 

pop , def  删

info = {'name': 'matt','age':'23', 'salary':'10000', 'job':'it' }
info.pop('name')
print(info)
del info['age']
print(info)

{'age': '23', 'salary': '10000', 'job': 'it'}
{'salary': '10000', 'job': 'it'}

 

 popitem()

info = {'name': 'matt','age':'23', 'salary':'10000', 'job':'it' }
info.popitem()
print(info)

{'name': 'matt', 'age': '23', 'salary': '10000'}

因为dictionary是无序的，所以是随机删除，在有序的list之中是删除最后一个

 

改

info = {'name': 'matt','age':'23', 'salary':'10000', 'job':'it' }
info['name'] = 'logan'
print(info)

{'name': 'logan', 'age': '23', 'salary': '10000', 'job': 'it'}

 

查   get(key , default = None)，访问字典中对应的键里的值，如不存在该键返回default的值

info = {'name': 'matt','age':'23', 'salary':'10000', 'job':'it' }
print('name' in info)
print(info.get('name'))
print(info['name'])

True
matt
matt

如果查找值不存在，get方法返回None，key方法直接报错

info.key获取所有键，info.value获取所有值

python字典包含了以下内置函数：
1、cmp(dict1, dict2)：比较两个字典元素。(python3后不可用)
2、len(dict)：计算字典元素个数，即键的总数。
3、str(dict)：输出字典可打印的字符串。
4、type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：
1、radiansdict.clear()：删除字典内所有元素
2、radiansdict.copy()：返回一个字典的浅复制
3、radiansdict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4、radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
5、radiansdict.has_key(key)：如果键在字典dict里返回true，否则返回false
6、radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组
7、radiansdict.keys()：以列表返回一个字典所有的键
8、radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
9、radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值

 集合

集合是一个无序的，不重复的数据组

#集合推导式
var = {'蚂蚱','螳螂','蝈蝈','蛐蛐'}

#基本的集合推导式
result = {'*'+i+'*' for i in var}
print(result)

#带有判断条件的集合推导式
result = {i for i in var if i != '蛐蛐'}
print(result)

#多循环集合推导式
colors = {'red','blue','pink'}
sizes = {36,37,38,39}
result = {c + str(s) for c in colors for s in sizes}
print(result)

#集合函数
'''
#add()  向集合中添加元素
girls = {'mf','sl','yj'}
girls.add('xf')
print(girls)

#pop()  随机删除集合中的一个元素
boys = {'bd','zw','jl','zy'}
result = boys.pop()
print(boys)
print(result)

#remove()  删除集合中指定的元素  删除不存在的元素会报错
boys = {'bd','zw','jl','zy'}
boys.remove('zy')
print(boys)

#discard()  删除集合中指定的元素  删除不存在的元素啥都不做
boys = {'bd','zw','jl','zy'}
boys.discard('zy1')
print(boys)

#clear()  清空集合
boys = {'bd','zw','jl','zy'}
boys.clear()
print(boys)

#copy()  复制集合
boys = {'bd','zw','jl','zy'}
newboys = boys.copy()
print(newboys)
'''

#difference() 计算2个集合的差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.difference(girls)# result = a + b
print(result)

#difference_update()  计算2个集合的差集(差集更新操作)
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.difference_update(girls)#a = a + b  a += b
print(dreamers)

#union()  并集操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.union(girls)
print(result)

#update()  并集更新操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.update(girls)
print(dreamers)

#intersection()  计算2个集合的交集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.intersection(girls)
print(result)

#intersection_update  交集更新操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.intersection_update(girls)
print(dreamers)

#超集和子集
boys = {'zzy','yqw','dw','wzc','lyb','wym','chy'}
zoudu = {'wzc','lyb','wym'}
girls = {'lsy','mmf','syj'}

#issuperset()  检测当前集合是否是另一个集合的超集
result = boys.issuperset(zoudu)
print(result)

#issubset()  检测当前集合是否是另一个集合的子集
result = zoudu.issubset(boys)
print(result)

#isdisjoint()  检测2个集合是否不存在交集  存在交集 False
result = boys.isdisjoint(girls)
print(result)

#symmetric_difference()  对称差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.symmetric_difference(girls)
print(result)

#symmetric_difference_update()  对称更新差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.symmetric_difference_update(girls)
print(dreamers)

#冰冻集合
#冰冻集合是一种特殊的集合类型,也是集合(集合是列表的话,冰冻集合就是元组)
#创建冰冻集合
#一般不会创建空的冰冻集合
var = frozenset()
print(var,type(var))

#带有数据的冰冻集合
var = frozenset(('qs','szx','bjh','acs'))
print(var,type(var))

#成员检测
result = 'szx' in var
print(result)

#遍历冰冻集合
for i in var:
    print(i)

#集合推导式(无法得到冰冻集合,可以得到集合,列表,元组,字典类型)
result = {i for i in var}
print(result,type(result))

#函数
#冰冻集合可以使用集合的函数(不修改集合本身的函数都可以使用)
var = frozenset(('qs','szx','bjh','acs'))

#copy()
result = var.copy()
print(result)

#集合操作  交集,并集,差集,对称差集等  不修改冰冻集合本身就能使用:冰冻集合的操作结果都是冰冻集合
var1 = frozenset(('qs','szx','bjh','acs'))
var2 = {'szx','bjh','lc','wb'}

#冰冻集合操作
result = var1.union(var2)
print(result)

#普通集合操作(冰冻集合是参考集合)
result = var2.union(var1)
print(result)

 

转载于:https://www.cnblogs.com/mushuiyishan/p/10459120.html