跟着ALEX 学python day2 基础2 模块数据类型运算符列表元组字典字符串的常用操作...

声明：

文档内容学习于

http://www.cnblogs.com/xiaozhiqi/

模块初始：

Python的强大之处在于他有非常丰富和强大的标准库和第三方库，几乎你想实现的任何功能都有相应的Python库支持，以后的课程中会深入讲解常用到的各种库，现在，我们先来象征性的学2个简单的。

模块就像一个个库。

有公共库和第三方的库

基础格式

import  sys（模块名称）

这边需要模块的名字不要和文件的名一致，因为默认情况下，他的模块会先从本地目录的文件中寻找，而你的自己的文件又不是这个库，所以会报错（python3这里的逻辑有优化，有时不会报错）。所以这边的话。文件名一定不能和模块名相一致。

模块与文件名不一致。

sys.path

这个模块是打印 python 调用库的环境变量的。

[root@master day1]# cat sys_mid.py
#!/usr/bin/env  python3import sysprint (sys.path)
[root@master day1]# ./sys_mid.py
['/root/python/day1', '/usr/local/python3/lib/python36.zip', '/usr/local/python3/lib/python3.6', '/usr/local/python3/lib/python3.6/lib-dynload', '/usr/local/python3/lib/python3.6/site-packages'

在windows 上面然后一般的标准库，都会在 lib下面

可以看到里面会有好多的py 文件。就是标准库

然后一般第三方库的会在 site-package 下面。

sys.argv

这个是打印文件的相对路径的

[root@master day1]# cat sys_mid.py
#!/usr/bin/env  python3import sysprint (sys.argv)
[root@master day1]# ./sys_mid.py
['./sys_mid.py']

可以用于和系统交互的模块，比如使用shell指令。

os.system系统交互

[root@master day1]# cat sys_mid.py
#!/usr/bin/env  python3import osos.system("ls")[root@master day1]# ./sys_mid.py
for.py  guess.py  interaction.py  passwd.py  print.py  sys_mid.py  var2.py  var.py

但是system这个模块只能进行执行（执行结果输出屏幕），不能进行存储结果（变量）。如下只能有os的执行输出，但是当os是变量时候，其实是没有输出内容的，只有一个执行的结果。

[root@master day1]# cat sys_mid.py
#!/usr/bin/env  python3

import oscmd_re = os.system("ls")
print ("-->",cmd_re)
[root@master day1]# ./sys_mid.py
for.py  guess.py  interaction.py  passwd.py  print.py  sys_mid.py  var2.py  var.py
--> 0

os.popen("指令").read()

这个指令分2部分，os.popen("指令")，可以将执行的内容存储到内存地址中。然后read()可以读取。

[root@master day1]# cat sys_mid.py
#!/usr/bin/env  python3import os
cmd_re = os.popen("ls").read()print ("-->",cmd_re)
[root@master day1]# ./sys_mid.py
--> for.py
guess.py
interaction.py
passwd.py
print.py
sys_mid.py
var2.py
var.py

如上可以看到。还是格式化输出的。

os.mkdir

创建目录

[root@master day1]# cat sys_mid.py
#!/usr/bin/env  python3
import osos.mkdir("new_dir")

导入第三方的模块

以上我们都是使用的系统自带的模块。其实我们也可以使用第三方的模块

使用自建的模块，其实就是自己写个脚本。然后使用另一个 py文件来调他就行了。

[root@master python]# ls
for.py  login.py  passwd.py  __pycache__  sys_mod.py
[root@master python]# cat login.py
#!/usr/bin/env python3username = "ricky"
passwd = 123name = input( "name:")
password = int( input ("passwd:"))if  username == name   and  passwd == password:print ( name,"wlecome")
else:print ("incorrent user")[root@master python]# cat sys_mod.py
#!/usr/bin/env python3
import   login                     #直接调用前面自己编写的模块
[root@master python]# ./sys_mod.py
name:ricky
passwd:123
ricky wlecome

但是我们这个使用2个脚本是在同一个目录下面。如果不在同一个目录下面。执行则会报错

然后如果要调用其他目录的模块。之前有说过。python会自动到他的系统路径下面去寻找模块。然后我们只要把脚本放到 site-package 这个第三方的库的目录中就可以了

我们把文件复制进去。

然后我们看就算同目录下面没有那个login的模块文件也可以执行了。

数据类型：

核心数据类型：

数字：int, long(python3.5已经没有), float, complex, bool
字符：str, unicode
列表：list
字典：dict
元组：tuple
集合：set(可变集合),frozenset(不可变集合)
文件：file

数字类型：

python的数字字面量：整数，布尔型，浮点数，复数，所有数字类型均为不可变

int（整型）

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

bool(布尔型)

真或假

1 或 0

float(浮点型)

数字操作：+ , -, *, /, //, **, %, -x, +x

bytes 和 string 转换

参考文档：

https://www.cnblogs.com/zanjiahaoge666/p/6402907.html

字符串转 2进制bytes

使用encode

mag = ("哈哈哈")
print( mag )print( mag.encode())                   #在python3中 如果不指定字符集， 默认就是utf-8。  python2不行。
print( mag.encode(encoding="utf-8"))   #效果同上

执行结果一样

2进制bytes转字符串

可以使用decode

print( mag )print( mag.encode())
print( mag.encode(encoding="utf-8"))print( mag.encode(encoding="utf-8").decode())                         #可以使用decode转， 一样的，如果不指定字符串，默认是utf-8
print( mag.encode(encoding="utf-8").decode(encoding="utf-8"))         # 执行结果如上

执行结果一样

算术运算符

以下假设变量： a=10，b=20：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方，输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -4.5 向下取整就是-5 -5

[root@master day1]# cat calculation.sh
#!/usr/bin/env python3a = 21
b = 10
c = 0c = a + b
print ( "a+b:", c)c = a - b
print ( "a-b:", c)c = a * b
print  ( "a*b:", c)c = a / b
print ( "a/b:", c)c = a % b
print ( "a%b:", c)a = 21
b = 10
c = a**bprint ("a**b:",c )a = 10
b = 5
c= a//bprint ("a//b:", c )

[root@master day1]# ./calculation.sh
a+b: 31
a-b: 11
a*b: 210
a/b: 2.1
a%b: 1
a**b: 16679880978201
a//b: 2

Python比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

Python赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

[root@master day1]# cat calculation.sh
#!/usr/bin/env python3a = 21
b = 10
c = 0c = a + b
print ("a+b:",c)c += a
print ("c +=a == c = c + a:",c)c *= a
print ("c *=a == c = c * a:",c)c /= a
print ("c /=a == c = c / a:",c)c %= a
print ("c %=a == c = c % a:",c)c **= a
print  ("c **= a == c = c ** a:",c)c //= a
print  ("c //= a == c = c // a:", c)[root@master day1]# ./calculation.sh
a+b: 31
c +=a == c = c + a: 52
c *=a == c = c * a: 1092
c /=a == c = c / a: 52.0
c %=a == c = c % a: 10.0                                    #这个是取摸。 c=52 a=21  返回除法的余数（整除的余数）    52 整除不了21 52 = 21*2+10
c **= a == c = c ** a: 1e+21                                # 10的21次方
c //= a == c = c // a: 4.761904761904762e+19

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

[root@master day1]# cat calculation.sh
#!/usr/bin/env python3a = 10
b = 20list = [ 1, 2, 3, 4, 5];print ("a=",a, "b=",b)if ( a in list):print ("a in list")
else:print ( "a not  in list")if ( b not in list):print ("b not in list")
else:print  ("b in list")a =2
print ("a=",a)if ( a in  list):print ("a in list")
else:print  ("a not in list")[root@master day1]# ./calculation.sh
a= 10 b= 20
a not  in list
b not in list
a= 2
a in list

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

其实 is 和 “=” 作用类似。但是有区别

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

更多运算符的运用查看

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

列表

类似于shell中的数组，取下标就可以了。

[root@localhost python]# cat name.py
#!/usr/bin/env python3
names = [ "aaa", "bbb" , "ccc"]print (names[0])
print (names[1])
[root@localhost python]# ./name.py
aaa
bbb

取最后一位可以是 -1，倒数第二位就是-2

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]print (names[-1])
[root@localhost python]# ./name.py
ddd

len 打印列表长度，可以

[root@localhost python]# cat  ./name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "fadfa","ccc", "ddd", "@!dfa","ASfd"]
print  (len(names))

[root@localhost python]# ./name.py
7

enumerate

可以直接打印出列表的下标和内容。在循环列表取值的时候，可以用到。

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "fadfa","ccc", "ddd", "@!dfa","ASfd"]for i in  enumerate(names):print (i)for i,j in  enumerate(names):print (i,j)[root@localhost python]# ./name.py
(0, 'aaa')
(1, 'bbb')
(2, 'fadfa')
(3, 'ccc')
(4, 'ddd')
(5, '@!dfa')
(6, 'ASfd')
0 aaa
1 bbb
2 fadfa
3 ccc
4 ddd
5 @!dfa
6 ASfd

切片

取出几个连续的串，顾头不顾尾，

[root@localhost python]# cat  name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
print (names[0:3])
[root@localhost python]# ./name.py
['aaa', 'bbb', 'ccc']

反向取

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
print (names[-3:-1])
[root@localhost python]# ./name.py
['bbb', 'ccc']

如果要取到最后一位，后一位直接不写，就行了。同理从第一位开始取，首位也可以省略写。

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
print (names[0:])print (names[:3])
[root@localhost python]# ./name.py
['aaa', 'bbb', 'ccc', 'ddd']['aaa', 'bbb', 'ccc']

根据内容查找下标，使用 .index

[root@localhost python]# cat  name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
print (names.index("aaa"))
[root@localhost python]# ./name.py
0

步长切片，就是不是连续打印

[root@master python]# cat name2.py
#!/usr/bin/env python3names = ["aaa","bbb","ccc","ddd"]print (names[0:-1:2])              #这样就是相隔打印一下
[root@master python]# ./name2.py
['aaa', 'ccc']

追加

append

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
names.append ("eee")    #直接写入内容就行了
print (names)
[root@localhost python]# ./name.py
['aaa', 'bbb', 'ccc', 'ddd', 'eee']

插入到指定位置

insert

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
names.append ("eee")
names.insert (1,"ababab")     # 写入下标，其实就是插入的位置， 然后是插入的内容
print (names)
[root@localhost python]# ./name.py
['aaa', 'ababab', 'bbb', 'ccc', 'ddd', 'eee']

修改

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
names[2] = "999999"                   #进行修改替换
print (names)
[root@localhost python]# ./name.py
['aaa', 'bbb', '999999', 'ddd']

多重列表修改

就是有列表套列表的时候进行修改。方法其实和上面一样就是，多写几个下标就行了。

[root@master python]# cat name.py
#!/usr/bin/env python3names = ["aaa","bbb",["1111", "2222"], "ddd"]
print (names)names[2][0] = ("5555")
print (names)
[root@master python]# ./name.py
['aaa', 'bbb', ['1111', '2222'], 'ddd']
['aaa', 'bbb', ['5555', '2222'], 'ddd']

删除

1. names.remove

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
names.remove("aaa")     #输入内容
print (names)
[root@localhost python]# ./name.py
['bbb', 'ccc', 'ddd']

2.del

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
del names[0]      #输入下标
print (names)

[root@localhost python]# ./name.py
['bbb', 'ccc', 'ddd']

也可以删除整个列表。

如上直接报错了。因为没有 names这个变量了。

3.pop

效果和 del 类似。就是如果不写下标的话，默认就是删除最后一位。

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
names.pop()print (names)names.pop(1)
print (names)
[root@localhost python]# ./name.py
['aaa', 'bbb', 'ccc']
['aaa', 'ccc']

计数

count

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
print (names.count("aaa"))                        #直接输入内容
[root@localhost python]# ./name.py
1

清空列表

clear

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
names.clear()  print (names)
[root@localhost python]# ./name.py
[]

反转

就是整个列表的顺序都反过来了

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "ccc", "ddd"]
names.reverse()print (names)
[root@localhost python]# ./name.py
['ddd', 'ccc', 'bbb', 'aaa']

排序

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "fadfa","ccc", "ddd", "@!dfa","ASfd"]
names.sort()
print (names)
[root@localhost python]# ./name.py
['@!dfa', 'ASfd', 'aaa', 'bbb', 'ccc', 'ddd', 'fadfa']

合并

就是将2个列表合并到一个列表

[root@localhost python]# cat  name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "fadfa","ccc", "ddd", "@!dfa","ASfd"]
names2 = [1,2,3,5]print (names)
names.extend(names2)                                #2个列表进行合并。同时被合并的列表也会保留
print (names,names2)

[root@localhost python]# ./name.py
['aaa', 'bbb', 'fadfa', 'ccc', 'ddd', '@!dfa', 'ASfd']
['aaa', 'bbb', 'fadfa', 'ccc', 'ddd', '@!dfa', 'ASfd', 1, 2, 3, 5] [1, 2, 3, 5]

copy 浅复制也称呼为浅copy

可以这样复制

[root@localhost python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb" , "fadfa","ccc", "ddd", "@!dfa","ASfd"]
names2 = names[:]
print (names2)

[root@localhost python]# ./name.py
['aaa', 'bbb', 'fadfa', 'ccc', 'ddd', '@!dfa', 'ASfd']

也可以直接复制列表

[root@master python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb", "ccc", "ddd"]
names2 = names.copy()print (names)
print (names2)
[root@master python]# ./name.py
['aaa', 'bbb', 'ccc', 'ddd']
['aaa', 'bbb', 'ccc', 'ddd']

但是修改了原来的列表。复制的那份并没有改。原理就和复制变量一样。其实他是用的内存指针的方式进行copy的。如下

[root@master python]# cat name.py
#!/usr/bin/env python3names = [ "aaa", "bbb", "ccc", "ddd"]
names2 = names.copy()print (names)
print (names2)
names[1] = ("bababa")
print (names)
print (names2)[root@master python]# ./name.py
['aaa', 'bbb', 'ccc', 'ddd']
['aaa', 'bbb', 'ccc', 'ddd']
['aaa', 'bababa', 'ccc', 'ddd']
['aaa', 'bbb', 'ccc', 'ddd']

但是这个只是浅copy，当你是复制是多重列表的时候，你修改了深层的列表的时候，那复制的那个列表。就会进行改变

[root@master python]# cat name.py
#!/usr/bin/env python3names = ["aaa","bbb",["1111", "2222"], "ddd"]
name2 = names.copy()
print (names)names[1] = ("babab")
names[2][0] = ("5555")
print (names)
print (name2)

[root@master python]# ./name.py
['aaa', 'bbb', ['1111', '2222'], 'ddd']
['aaa', 'babab', ['5555', '2222'], 'ddd']
['aaa', 'bbb', ['5555', '2222'], 'ddd']

浅copy的用处

可以创建联合账号，就像是夫妻拥有共同的账户，然后当一方消费之后，2个人账户余额都会发生变化。

[root@localhost python]# cat name2.py
#!/usr/bin/env python3person = [ "name",["saving","100"] ]
p1 = person.copy()
p2 = person.copy()p1[0] = "husband"
p2[0] = "wife"p1[1][1] = 50print (p1)
print (p2)[root@localhost python]# ./name2.py
['husband', ['saving', 50]]
['wife', ['saving', 50]]

深copy

完全复制，就是当原来的列表，无论怎么改的情况下。复制的那份列表也不会改变。

需要使用 import copy 模块

[root@master python]# cat name.py
#!/usr/bin/env python3
import copynames = ["aaa","bbb",["1111", "2222"], "ddd"]
name2 = copy.deepcopy(names)      #注意这边一定是使用deepcopy。 否则还是浅copy
print (names)names[1] = ("babab")
names[2][0] = ("5555")
print (names)
print (name2)

[root@master python]# ./name.py
['aaa', 'bbb', ['1111', '2222'], 'ddd']
['aaa', 'babab', ['5555', '2222'], 'ddd']
['aaa', 'bbb', ['1111', '2222'], 'ddd']

如上，可以看到，无论原始的列表改了第一层还是更深的层次。 copy的names2 都不会变化。

列表循坏

和shell类似

[root@master python]# cat name2.py
#!/usr/bin/env python3names = ["aaa","bbb",["1111", "2222"], "ddd"]for i in names:print (i)[root@master python]# ./name2.py
aaa
bbb
['1111', '2222']
ddd

元组

作用类似于列表，但是只能只读。不能修改。所以也叫只读列表

基础语法，和列表类似

[root@localhost python]# cat tuple.py
#!/usr/bin/env python3names = ( "aaa" , "bbbb")print  ( names[1] )[root@loca

而且它只有 count和index参数可以使用

[root@localhost python]# cat tuple.py
#!/usr/bin/env python3names = ( "aaa" , "bbbb")

print  ( names.count("aaa") )
print  ( names.index("aaa") )

[root@localhost python]# ./tuple.py
1
0

字符串的常用操作

capitalize  首字母大写

[root@master day2]# cat strings.pt
#!/usr/bin/env  python3name =  ("haha")
print  (name.capitalize())[root@master day2]# ./strings.pt
Haha

count 统计字符串中某一个字符的数字。

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("haha")
print  (name.count("a"))
[root@master day2]# ./strings.py
2

center 居中打印。同时可以规定字符串的长度

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("haha")
print  (name.center(50,"-"))
# 这边的意思是打印50个字符串， 如果变量中的字符串不够，则用"-"代替。
[root@master day2]# ./strings.py
-----------------------haha-----------------------

endswith  判断一段字符串以什么结尾

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("haha")
print  (name.endswith("a"))
print  (name.endswith("b"))[root@master day2]# ./strings.py
True
False

expandtabs   定义一些格式字符的长度（如tab健）

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("ha \tha")
print  (name.expandtabs(tabsize=30))#  这里是定义了tab 健的长度[root@master day2]# ./strings.py
ha                            ha

find 找到这个字符的下标，这个找到的从左边数，第一个找的的字符的下标

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("abcde")print  (name.find("a"))[root@master day2]# ./strings.py
0

rfind 这个找到的从右边数，第一个找的字符的下标（字符对应的下标不变）

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("abcdea")print  (name.find("a"))
print  (name.rfind("a"))[root@master day2]# ./strings.py
0
5   #字符对应的下标不变， 只是找寻的方式变了

isalnum 判断字符串里面是否只有数字和字母

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("abcde")
name1 = ("abc123")
name2 = ("dadaf123!@")print  (name.isalnum())
print  (name1.isalnum())
print  (name2.isalnum())[root@master day2]# ./strings.py
True
True
False

isalpha 是都是纯英文（包括大小写）

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("abcde")
name1 = ("abc123")print  (name.isalpha())
print  (name1.isalpha())
[root@master day2]# ./strings.py
True
False

isidentifier  判断是否是一个合法的变量名

[root@master day2]# cat  strings.py
#!/usr/bin/env  python3name =  ("abcde")
name1 = ("abc123")
name2 = ("dadaf123!@")print  ("dada".isidentifier())
print  ("1dada".isidentifier())
# 之前有说过。数字是不行作为变量名开头的[root@master day2]# ./strings.py
True
False

print  (name.islower())   判断是不是小写print  (name.upper())     判断是不是大写print (name.isspace())    判断是不是空格

istitle  判断是不是首字母大写

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("My name is")
name1 =  ("My Name  Is")print  (name.istitle())
print  (name1.istitle())[root@master day2]# ./strings.py
False
True

join  将列表变成字符串。同时定义分隔符

[root@master day2]# cat strings.py
#!/usr/bin/env  python3print  (''.join(['1','2','3']))
print  ('+'.join(['1','2','3']))
# 可以定义分隔符，可以不写。[root@master day2]# ./strings.py
123
1+2+3

ljust，rjust  都是定义字符串的长度，然后可以定义不够部分补齐的字符。

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("My name is")print  (name.ljust(50,"*"))
print  (name.rjust(50,"-"))[root@master day2]# ./strings.py
My name is****************************************
----------------------------------------My name is

lower  将字符串变小写   upper  将字符串变大写

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("My name is")print  (name.lower())
print  (name.upper())
[root@master day2]# ./strings.py
my name is
MY NAME IS

strip  可以去掉字符串2边的空格和回车lstrip  可以去掉字符串左边的空格和回车 lstrip 可以去掉字符右边的空格和回车

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("My name is")print  (name)
print  ("\nname")
print  ("name\n")
print  ("\n    name   ")
print  ("--")
[root@master day2]# ./strings.py
My name isname
namename
--

[root@master day2]# cat strings2.py
#!/usr/bin/env  python3name =  ("My name is")print  (name)
print  ("\nname".lstrip())                 #去掉左边的空格和回车
print  ("name\n".rstrip())                 #去掉右边的空格和回车
print  ("\n    name   ".strip())           #去掉两边空格和回车
print  ("--")
[root@master day2]# ./strings2.py
My name is
name
name
name
--

maketrans   自定义字符串转换。 类似于字符串的加密。看以下。打印的出来的是转义后的东西。

[root@master day2]# cat strings.py
#!/usr/bin/env  python3p = str.maketrans("abcdefghijklmn","1234567#@89&*)")
# 这边前面的字符数量和后面转移码的数量必须一致。否则会报错print ("my name is haha".translate(p))[root@master day2]# ./strings.py
*y )1*5 @s #1#1

replace  字符替换

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("my name is")print  (name.replace("m","M"))[root@master day2]# ./strings.py
My naMe is

默认是全部替换，也可以定义替换的数量

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("my name is")print  (name.replace("m","M",1))[root@master day2]# ./strings.py
My name is

split  将字符串变成列表，并指定分隔符（默认是空格是分隔符）

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("my name is ")print  (name.split())[root@master day2]# ./strings.py
['my', 'name', 'is']

指定分隔符

[root@master day2]# cat strings.py
#!/usr/bin/env  python3name =  ("my name is ")
print  (name.split("m"))  #可以使用m为分隔符，同时m被视为分隔符，不被打印[root@master day2]# ./strings.py
['', 'y na', 'e is ']

swapcase  大小写互换

[root@master day2]# cat strings.py
#!/usr/bin/env  python3print  ("NAme Is".swapcase())[root@master day2]# ./strings.py
naME iS

print  (name.title())    变成 tile，首字母大写。


字典字典 是一种key-value的数据类型

查

[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env pythoninfo = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"}print (info)
print (info["stau002"])
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}
Julia

以上只能用于确定key的情况下，。如果不确定key，需要使用info.get  ，就是没有这个key。程序也不会报错。

[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env pythoninfo = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"}print (info)
print (info.get("st10"))
print (info.get("stau001"))[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}
None
wutenglan

判断key是否存在

[root@master day2]# cat dictionary.py
#!/usr/bin/env  python3info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"
}print  ("stau001" in info )
print  ("stau006" in info )[root@master day2]# ./dictionary.py
True
False

只打印value或者只打印key

[root@master day2]# cat dictionary.py
#!/usr/bin/env  python3info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"
}print (info.values())
print (info.keys())[root@master day2]# ./dictionary.py
dict_values(['wutenglan', 'Julia', 'zuotenyaoxi', 'longzeluola', 'jizemingbu'])
dict_keys(['stau001', 'stau002', 'stau003', 'stau004', 'stau005'])


改就是给他进行赋值

root@mfsclient python]# cat dictionary.py
#!/usr/bin/env pythoninfo = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"}print (info)info["stau001"] = "cangjinkong"print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'cangjinkong', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}
[root@mfsclient python]#

增

其实方法和改的方法一样，就是加一个key，赋值原有的key就是改。赋值给没有的key就是加一个值。

[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env pythoninfo = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"}print (info)info["stau006"] = "Maria"print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau006': 'Maria', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}

删除

可以使用del

[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env pythoninfo = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"}print (info)del info["stau001"]print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}

如果要只能key的话。可以只用pop

[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env pythoninfo = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"}print (info)info.pop("stau001")
print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}

popitem随机删除一组，可以不指定key

[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env pythoninfo = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"}print (info)info.popitem()
print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}
{'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'jizemingbu'}

多级字典的嵌套和方法

多级字典

av_catalog = {"Europe":{"www.youporn.com": ["很多免费的,世界最大的","质量一般"],"www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],"x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]},"Asis":{"tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]},"mainland":{"1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]}
}print (av_catalog)

多级的改

[root@master day2]# cat Dic.py
#!/usr/bin/env  python3av_catalog = {"Europe":{"www.youporn.com": ["很多免费的,世界最大的","质量一般"],"www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],"x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]},"Asis":{"tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]},"mainland":{"1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]}
}print (av_catalog)av_catalog ["mainland"]["1024"][1] = ("aaaaa")
print (av_catalog)

执行结果

其他操作

setdefault

可以进行增加元素。同时可以判断key是否存在，如果存在。则该元素不增加。如果存在，增加该元素。

av_catalog = {"Europe":{"www.youporn.com": ["很多免费的,世界最大的","质量一般"],"www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],"x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]},"Asis":{"tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]},"mainland":{"1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]}
}

av_catalog.setdefault("HongKong",{"www.baidu.com":["papapa","momo"]})
print  (av_catalog)

注意看这个的setdefault 的写法，于上面不通。中间是，不是：

如果key不存在，则进行添加，如果key存在，则不生效。

update

可以将2个字典合并。如实有相同的key，则用新的字典中的key进行替换。

[root@master day2]# cat  dictionary.py
#!/usr/bin/env  python3info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"
}info2 = {
"stau001":"aaaa",
1:3,
2:4}info.update(info2)print (info)[root@master day2]# ./dictionary.py
{'stau001': 'aaaa', 'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau004': 'longzeluola', 'stau005': 'jizemingbu', 1: 3, 2: 4}

item

将字典转换整列表。而列表里面 key和value的形式以元组进行排列的。

[root@master day2]# cat dictionary.py
#!/usr/bin/env  python3info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"
}print (info.items())
[root@master day2]# ./dictionary.py
dict_items([('stau001', 'wutenglan'), ('stau002', 'Julia'), ('stau003', 'zuotenyaoxi'), ('stau004', 'longzeluola'), ('stau005', 'jizemingbu')])

fromkeys

给一个变量赋值字典，并且初始化这个字段。同时这个字典所有的值都是相同的

[root@master day2]# cat dictionary.py
#!/usr/bin/env  python3C = dict.fromkeys([6,7,8],("hahah"))
# 其实这里的dict就是字典的意思，新创建的字典就是C这个变量
print (C)
[root@master day2]# ./dictionary.py
{6: 'hahah', 7: 'hahah', 8: 'hahah'}

字典的循环

就是个for循环。只不过他默认是指打印key的。所以需要这么写

[root@master day2]# cat  dictionary.py
#!/usr/bin/env  python3info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"
}for i in info:print (i,info[i])[root@master day2]# ./dictionary.py
stau001 wutenglan
stau002 Julia
stau003 zuotenyaoxi
stau004 longzeluola
stau005 jizemingbu

另一种循环

使用info.items，但是这个循环需要有个将字典转换成列表的过程。如果数据量大的情况下。非常影响性能。所以推荐上面这种。数据量不大的情况下。是一样的。

[root@master day2]# cat dictionary.py
#!/usr/bin/env  python3info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"jizemingbu"
}for i,j  in info.items():print (i,j)[root@master day2]# ./dictionary.py
stau001 wutenglan
stau002 Julia
stau003 zuotenyaoxi
stau004 longzeluola
stau005 jizemingbu

转载于:https://www.cnblogs.com/rockyricky/p/10515513.html