文章目录
模块引入格式
可变对象&不可变对象
不可变对象: int，float，long，str，tuple等，
可变对象包括: list，set，dict等
可变对象和不可变对象的本质差异在于对象是否可以修改。如果可以修改，则是可变对象。如果两个变量指向同一可变对象，修改其中一个变量，会导致另一变量的改变。如果不可以修改，则是不可变对象。如果两个变量指向同一对象，修改其中一个可变变量，不会导致另一可变变量的改变。（因为会新建一个对象，原对象不变）
————————————————
版权声明：本文为CSDN博主「CaoChengtai」的原创文章，遵循CC 4.0
BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_37589575/article/details/104829042
函数参数
python的参数修改，传进来的参数再函数外也会对应修改，如果希望不影响到函数外的值，则应该创建一个副本来进行参数传递，例如列表 lis[:] 则创建了一个列表副本，从而函数内的修改不会影响到 lis
Python支持连续比较
6 > -3 < -1返回为 true， 因为它等价于 6 > -3 and -3 < -1（注意与其他语言区分）
<< 按位左移
左移操作，左移一位相当于乘以b，a<<b,a’ = a*(2^b)
print(2<<3) # 2*2^3 = 16，2的二进制10，向左移动3位后10000
print(2<<1) # 2*2^1 = 4
print(3<<4) # 3*2^4 = 48,3的二进制为11，向左移动四位后110000
16
4
48
>> 按位右移
右移操作，右移一位相当于除以b,a<<b,a’ = a//(2^b)注意这里是整除，当向右移动位数大于能移动的位数时，置为0【可以理解为会将尾巴截掉】
print(2>>3) # 2//2^3 = 0，2的二进制10，向右最多移动2位后，所以多移动无疑为0
print(2>>1) # 2*2^1 = 4，向右移动一位为01,
print(3>>4) # 3*2^4 = 48,3的二进制为11，向右移动四位后00
print(3>>1) # 3*2^4 = 48,3的二进制为11，向右移动一位后为01
0
1
0
1
- 而>>=和<<=，就是对变量进行位运算移位之后的结果再赋值给原来的变量，可以类比赋值运算符+=和-=可以理解。
比如x>>=2， 就是把变量x右移2位，再将操作后的值赋值给x。
ord()
将字符转换为ASCII码：ord(‘a’) 返回 97
chr()
将ASCII转换为对应字符： chr(97) 返回 ‘a’
map()
会根据提供的函数对指定序列做映射
>>> def square(x) : # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
str
encode()
用于将 str 类型转换成 bytes 类型，这个过程也称为“编码”。
decode()
decode() 方法用于将 bytes 类型的二进制数据转换为 str 类型，这个过程也称为“解码”。
.join()
s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))
.split()
split(str=“”, num=string.count(str))
以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
.strip
- lstrip()
截掉字符串左边的空格或指定字符。 - rstrip()
删除字符串末尾的空格或指定字符。 - strip([chars])
在字符串上执行 lstrip()和 rstrip()
find(str, beg=0, end=len(string))
检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
python 字符串格式化输出
name = '阿昌'
print("大家好，我叫%s"%name)
re 正则表达式
正则表达式教程
教程中附带笔记
re.match函数
re.match(pattern, string, flags=0)
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
pattern : 匹配的正则表达式
string : 要匹配的字符串
flags : 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配
re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为’ . ‘并且包括换行符在内的任意字符（’ . '不包括换行符）
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性，忽略空格和’ # '后面的注释
eg
import re
print(re.match('www', 'www.baidu.com').span()) # 在起始位置匹配
print(re.match('com', 'www.baidu.com')) # 不在起始位置匹配
(0, 3)
None
line = "Cats are smarter than dogs"
# .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符
# (.*?) 表示"非贪婪"模式，只保存第一个匹配到的子串
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
print ("matchObj.group() : ", matchObj.group())
print ("matchObj.group(1) : ", matchObj.group(1))
print ("matchObj.group(2) : ", matchObj.group(2))
else:
print ("No match!!")
输出：
matchObj.group() : Cats are smarter than dogs
matchObj.group(1) : Cats
matchObj.group(2) : smarter
group groups
m.group() = = m.group(0) = = 所有匹配的字符(即匹配正则表达式整体结果)
group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。
m.groups() 返回所有括号匹配的字符，以tuple格式。m.groups() == (m.group(0), m.group(1), …)
re.search
re.search 扫描整个字符串并返回第一个成功的匹配
re.search(pattern, string, flags=0)
区分：
re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None
re.search 匹配整个字符串，直到找到一个匹配。
eg.
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs"
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
print ("match --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
print ("search --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
输出：
No match!!
search --> matchObj.group() : dogs
re.sub 检索和替换
Python 的re模块提供了re.sub用于替换字符串中的匹配项。
re.sub(pattern, repl, string, count=0, flags=0)
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
flags : 编译时用的匹配模式，数字形式。
eg.
phone = "2004-959-559 # 这是一个电话号码"
# 删除注释
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num)
# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num)
输出：
电话号码 : 2004-959-559
电话号码 : 2004959559
repl 参数是一个函数 举例
import re
# 将匹配的数字乘以 2
def double(matched):
value = int(matched.group('value'))
return str(value * 2)
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s)) # ?P<value>的意思就是命名一个名字为value的组，匹配规则符合后面的/d+
输出：
A46G8HFD1134
compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
re.compile(pattern[, flags])
>>>import re
>>> pattern = re.compile(r'\d+') # 用于匹配至少一个数字
>>> m = pattern.match('one12twothree34four') # 查找头部，没有匹配
>>> print( m )
None
>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
>>> print( m )
None
>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
>>> print( m ) # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0) # 可省略 0
'12'
>>> m.start(0) # 可省略 0
3
>>> m.end(0) # 可省略 0
5
>>> m.span(0) # 可省略 0
(3, 5)
在上面，当匹配成功时返回一个 Match 对象，其中：
group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
span([group]) 方法返回 (start(group), end(group))。
sys
sys模块，它里面提供了一些变量和函数,使我们可以获取到Python解析器的信息，或者通过函数来操作Python解析器
- sys.argv
获取执行代码时，命令行中所包含的参数
该属性是一个列表，列表中保存了当前命令的所有参数 - sys.modules
获取当前程序中引入的所有模块
modules是一个字典，字典的key是模块的名字，字典的value是模块对象
pprint.pprint(sys.modules)
pprint 模块它给我们提供了一个方法 pprint()该方法可以用来对打印的数据做简单的格式化 - sys.path
他是一个列表，列表中保存的是模块的搜索路径，类似于环境变量 - sys.platform
表示当前Python运行的平台 - sys.exit()
用来退出程序
os
os模块让我们可以对操作系统进行访问
- os.environ
通过这个属性可以获取到系统的环境变量 - os.system( )
可以用来执行操作系统的命令
os.system(‘dir’)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
