声明 ：
文档内容学习于
http://www.cnblogs.com/xiaozhiqi/
模块初始：
Python的强大之处在于他有非常丰富和强大的标准库和第三方库，几乎你想实现的任何功能都有相应的Python库支持，以后的课程中会深入讲解常用到的各种库，现在，我们先来象征性的学2个简单的。
模块 就像一个个库。
有公共库 和第三方的库
基础格式
import sys（模块名称）
这边需要 模块的名字不要和 文件的名一致 ， 因为默认情况下，他的模块会先从本地目录的文件中寻找，而你的自己的文件又不是这个库，所以会报错（python3这里的逻辑有优化，有时不会报错）。 所以这边的话。文件名一定不能和模块名相一致。
模块与文件名不一致。
sys.path
这个模块是打印 python 调用库的 环境变量的。
[root@master day1]# cat sys_mid.py
#!/usr/bin/env python3 import sys print (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 python3 import sys print (sys.argv)
[root@master day1]# ./sys_mid.py
['./sys_mid.py']
os
可以用于和系统交互的模块，比如使用shell指令。
os.system
系统交互
[root@master day1]# cat sys_mid.py
#!/usr/bin/env python3 import os os.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 os cmd_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 python3 import 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 os os.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 python3 username = "ricky"
passwd = 123 name = 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
在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 |
[root@master day1]# cat calculation.sh
#!/usr/bin/env python3 a = 21
b = 10
c = 0 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) c = a % b
print ( "a%b:", c) a = 21
b = 10
c = a**b print ("a**b:",c ) a = 10
b = 5
c= a//b print ("a//b:", c ) [root@master day1]# ./calculation.sh
a+b: 31
a-b: 11
a*b: 210
a/b: 2.1
a%b: 1 # 能够整除后，还能余下的数字。 若除数比被除数小，则返回除数， 例： 3%5 ，因为3比5小。 无法整除，所以返回3.
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 python3 a = 21
b = 10
c = 0 c = 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 python3 a = 10
b = 20 list = [ 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 python3 names = [ "aaa", "bbb" , "ccc", "ddd"] print (names[-1])
[root@localhost python]# ./name.py
ddd
len 打印列表长度，可以
[root@localhost python]# cat ./name.py
#!/usr/bin/env python3 names = [ "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 python3 names = [ "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 python3 names = [ "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 python3 names = [ "aaa", "bbb" , "ccc", "ddd"]
print (names[-3:-1])
[root@localhost python]# ./name.py
['bbb', 'ccc']
如果要取到最后一位，后一位直接不写，就行了。 同理从第一位开始取，首位也可以省略写。
[root@localhost python]# cat name.py
#!/usr/bin/env python3 names = [ "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 python3 names = [ "aaa", "bbb" , "ccc", "ddd"]
print (names.index("aaa"))
[root@localhost python]# ./name.py
0
步长切片，就是不是连续打印
[root@master python]# cat name2.py
#!/usr/bin/env python3 names = ["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 python3 names = [ "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 python3 names = [ "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 python3 names = [ "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 python3 names = ["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 python3 names = [ "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 python3 names = [ "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 python3 names = [ "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 python3 names = [ "aaa", "bbb" , "ccc", "ddd"]
print (names.count("aaa")) #直接输入内容
[root@localhost python]# ./name.py
1
清空列表
clear
[root@localhost python]# cat name.py
#!/usr/bin/env python3 names = [ "aaa", "bbb" , "ccc", "ddd"]
names.clear() print (names)
[root@localhost python]# ./name.py
[]
反转
就是整个列表的顺序都反过来了
[root@localhost python]# cat name.py
#!/usr/bin/env python3 names = [ "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 python3 names = [ "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 python3 names = [ "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 python3 names = [ "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 python3 names = [ "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 python3 names = [ "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 python3 names = ["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 python3 person = [ "name",["saving","100"] ]
p1 = person.copy()
p2 = person.copy() p1[0] = "husband"
p2[0] = "wife" p1[1][1] = 50 print (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 copy names = ["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 python3 names = ["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 python3 names = ( "aaa" , "bbbb") print ( names[1] ) [root@loca
而且它只有 count和index参数可以使用
[root@localhost python]# cat tuple.py
#!/usr/bin/env python3 names = ( "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 python3 name = ("haha")
print (name.capitalize()) [root@master day2]# ./strings.pt
Haha
count 统计 字符串中 某一个字符的数字。
[root@master day2]# cat strings.py
#!/usr/bin/env python3 name = ("haha")
print (name.count("a"))
[root@master day2]# ./strings.py
2
center 居中打印。同时 可以规定字符串的长度
[root@master day2]# cat strings.py
#!/usr/bin/env python3 name = ("haha")
print (name.center(50,"-"))
# 这边的意思是打印50个字符串， 如果变量中的字符串不够，则用"-"代替。
[root@master day2]# ./strings.py
-----------------------haha-----------------------
endswith 判断一段字符串以什么结尾
[root@master day2]# cat strings.py
#!/usr/bin/env python3 name = ("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 python3 name = ("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 python3 name = ("abcde") print (name.find("a")) [root@master day2]# ./strings.py
0
rfind 这个找到的从右边数，第一个找的字符的下标（字符对应的下标不变）
[root@master day2]# cat strings.py
#!/usr/bin/env python3 name = ("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 python3 name = ("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 python3 name = ("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 python3 name = ("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 python3 name = ("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 python3 print (''.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 python3 name = ("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 python3 name = ("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 python3 name = ("My name is") print (name)
print ("\nname")
print ("name\n")
print ("\n name ")
print ("--")
[root@master day2]# ./strings.py
My name is name
name name
-- [root@master day2]# cat strings2.py
#!/usr/bin/env python3 name = ("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 python3 p = 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 python3 name = ("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 python3 name = ("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 python3 name = ("my name is ") print (name.split()) [root@master day2]# ./strings.py
['my', 'name', 'is']
指定分隔符
[root@master day2]# cat strings.py
#!/usr/bin/env python3 name = ("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 python3 print ("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 python info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu" } print (info)
print (info["stau002"])
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
Julia
以上只能用于确定key的情况下，。如果不确定key，需要使用info.get ，就是没有这个key。程序也不会报错。
[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env python info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu" } print (info)
print (info.get("st10"))
print (info.get("stau001")) [root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
None
wutenglan
判断key是否存在
[root@master day2]# cat dictionary.py
#!/usr/bin/env python3 info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu"
} 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 python3 info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu"
} print (info.values())
print (info.keys()) [root@master day2]# ./dictionary.py
dict_values(['wutenglan', 'Julia', 'zuotenyaoxi', 'longzeluola', 'ji*gbu'])
dict_keys(['stau001', 'stau002', 'stau003', 'stau004', 'stau005'])
改
就是给他进行赋值
root@mfsclient python]# cat dictionary.py
#!/usr/bin/env python info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu" } print (info) info["stau001"] = "cangjinkong" print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'cangjinkong', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
[root@mfsclient python]#
增
其实方法和改的方法一样，就是加一个key， 赋值原有的key就是改。 赋值给没有的key就是加一个值。
[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env python info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu" } print (info) info["stau006"] = "Maria" print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau006': 'Maria', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
删除
可以使用del
[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env python info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu" } print (info) del info["stau001"] print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
如果要只能key的话。可以只用pop
[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env python info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu" } print (info) info.pop("stau001")
print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
popitem随机删除一组，可以不指定key
[root@mfsclient python]# cat dictionary.py
#!/usr/bin/env python info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu" } print (info) info.popitem()
print (info)
[root@mfsclient python]# ./dictionary.py
{'stau002': 'Julia', 'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
{'stau003': 'zuotenyaoxi', 'stau001': 'wutenglan', 'stau004': 'longzeluola', 'stau005': 'ji*gbu'}
多级字典的嵌套和方法
多级字典
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 python3 av_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 python3 info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu"
} 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': 'ji*gbu', 1: 3, 2: 4}
item
将字典转换整列表。而列表里面 key和value的形式以元组进行排列的 。
[root@master day2]# cat dictionary.py
#!/usr/bin/env python3 info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu"
} print (info.items())
[root@master day2]# ./dictionary.py
dict_items([('stau001', 'wutenglan'), ('stau002', 'Julia'), ('stau003', 'zuotenyaoxi'), ('stau004', 'longzeluola'), ('stau005', 'ji*gbu')])
fromkeys
给一个变量赋值字典，并且初始化这个字段。同时这个字典所有的值都是相同的
[root@master day2]# cat dictionary.py
#!/usr/bin/env python3 C = 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 python3 info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu"
} for i in info:
print (i,info[i]) [root@master day2]# ./dictionary.py
stau001 wutenglan
stau002 Julia
stau003 zuotenyaoxi
stau004 longzeluola
stau005 ji*gbu
另一种循环
使用info.items，但是这个循环需要有个将字典转换成列表的过程。如果数据量大的情况下。 非常影响性能。所以推荐上面这种。数据量不大的情况下。是一样的。
[root@master day2]# cat dictionary.py
#!/usr/bin/env python3 info = {
"stau001":"wutenglan",
"stau002":"Julia",
"stau003":"zuotenyaoxi",
"stau004":"longzeluola",
"stau005":"ji*gbu"
} for i,j in info.items():
print (i,j) [root@master day2]# ./dictionary.py
stau001 wutenglan
stau002 Julia
stau003 zuotenyaoxi
stau004 longzeluola
stau005 ji*gbu