Python基础语法-day1
数值
print(True+False) # 输出1，True默认为1，False为0
print(True or False) # 输出True，关键字or执行“或”操作
print(5//2) # 输出2，//为取整运算符
print(5%2) # 输出1，%为取余运算符
print(3**2) # 输出9，**表示乘方操作
print(5+1.6) # 输出6.6，不同精度的类型的数字相加默认取高精度类型作为结果
1
True
2
1
9
6.6
字符串
ASCII编码1字节，如0x65，二进制01000001
unicode编码2字节。
字符串和其整数表述 ord() 、chr()
字符串类型str，字节bytes用b前缀x=b'ABC'
str用ASCII编码变成bytes，但bytes无法显示为ASCII字符的字节
S = 'python' # 给变量S赋值 python
# len(obj): 返回对象的长度
print(len(S)) # 输出6
print(S[0],S[1],S[-1]) # 输出pyn ，按照索引获取元素
print(S+'1',S*2) # 输出python1 pythonpython：合并和重复
# str.split(str="", num=-1)：通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串,-1表示分割所有。
print(S.split('h')) # 输出[‘pyt’,’on’]，根据h对字符串切割
# str.replace(old, new[, max])：返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
print(S.replace('py','PY')) # Python，将字符串中的py替换为PY
# str.upper()：返回小写字符转化为大写后的值。
print(S.upper()) # PYTHON
# str.lower()：返回大写字符转化为小写后的值。
print('PYTHON'.lower()) # python，字符串转小写
line='aa,bb,ccc,dd\n' # \n 为换行
# str.join(sequence)：sequence：要连接的序列，返回指定字符连接序列中元素后生成的新字符串。
print(''.join(['life', 'is' ,'short'])) # 输出life is short，join拼接字符串
hw12='%s %s %d' % ('hello','world',12) # 格式化字符串
print(hw12) # 输出hello world 12
6
p y n
python1 pythonpython
[‘pyt’, ‘on’]
PYthon
PYTHON
python
lifeisshort
hello world 12
S = 'python' # 变量赋值
S[0] = 'Z' # 程序异常（报错）
S1 ='Z'+S[1:] # 生成了新的字符串 Zython，并赋值给S1
print("S:%s,S1:%s"%(S,S1)) # 输出S:python，S1:Zython
string不可对单个位置赋值
列表
list有序，可以删除和添加
tuple元组：一旦初始化就不能修改元素，但如果元素是list类型即可以修改
animals = ['cat', 'dog', 'monkey']
# list.append(obj)：在列表末尾添加新的对象。
animals.append('fish') # 追加元素
print(animals) # 输出 ['cat', 'dog', 'monkey', ‘fish’]
# list.remove(obj)：移除列表中某个值的第一个匹配项。
animals.remove('fish') # 删除元素fish
print(animals) # 输出 ['cat', 'dog', 'monkey']
# list.insert(index, obj)：用于将指定对象插入列表的指定位置。index：插入位置
animals.insert(1,'fish') # 在下标1的地方插入元素fish
print(animals) # 输出 ['cat', ‘fish’, 'dog', 'monkey']
# list.pop([index=-1])：要移除列表中对下标对应的元素（默认是最后一个）。Index：下标
animals.pop(1) # 删除下标为1的元素
print(animals) # 输出 ['cat', 'dog', 'monkey']
#遍历并获取元素和对应索引
# enumerate(sequence) ：将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
for i in enumerate(animals):
print(i) # 元素下标和元素所组成的索引
#列表推导式
squares = [x*2 for x in animals] # 批量生成符合规则的元素组成的列表
print(squares) #['catcat ', 'dogdog ', 'monkeymonkey ']
list1 = [12,45,32,55]
# list.sort(cmp=None, key=None, reverse=False)：cmp为可选参数, 如果指定了该参数，会使用该参数的方法进行排序。key是用来进行比较的元素。reverse为排序规则，False为升序。
list1.sort() # 对列表进行排序
print(list1) # 输出[12,32,45,55]
# list.reverse()：反向列表中元素。
list1.reverse() # 对列表进行逆置
print(list1) # 输出[55,45,32,12]
[‘cat’, ‘dog’, ‘monkey’, ‘fish’]
[‘cat’, ‘dog’, ‘monkey’]
[‘cat’, ‘fish’, ‘dog’, ‘monkey’]
[‘cat’, ‘dog’, ‘monkey’]
(0, ‘cat’)
(1, ‘dog’)
(2, ‘monkey’)
[‘catcat’, ‘dogdog’, ‘monkeymonkey’]
[12, 32, 45, 55]
[55, 45, 32, 12]
元组
T=(1,2,3) #创建元组
print(T+(4,5)) #元组合并，输出：(1, 2, 3, 4, 5)
t=(42,) #只有一个元素的元组，区别于数字
tuple1 = (12,45,32,55,[1,0,3]) # 创建元祖
tuple1[0] = "good" # 程序异常，元组的不可变性（报错）
tuple1[4][0] = 2 # 元组中可变的元素是可以变得
print(tuple1)
(1, 2, 3, 4, 5)
(12, 45, 32, 55, [2, 0, 3])
字典
# 字典的三种赋值操作
x = {'food':'Spam','quantity':4,'color':'pink'}
X =dict(food='Spam',quantity=4, color='pink')
x = dict([("food", "Spam"),("quantity", "4"),("color","pink")])
# dict.copy()：拷贝数据
d =x.copy()
d['color'] = 'red'
print(x) # {'food':'Spam','quantity':4,'color':'pink'}
print(d) # {'food':'Spam','quantity':4,'color':'red'}
#元素访问
print(d['name']) # 得到错误信息
print(d['color']) # 正常 得red
---------------------------------------------------
print(d.get('name')) # 输出None
print(d.get('name','键值不存在！')) # 输出 键值不存在
print(d.keys()) # 输出dict_keys(['food', 'quantity', 'color'])
print(d.values()) # 输出dict_values(['Spam', 4, 'red'])
print(d.items())
# 输出 dict_items([('food', 'Spam'), ('quantity', 4), ('color', 'red')])
d.clear() # 清空字典中的所有数据
print(d) # 输出 {}
del(d) # 删除字典
print(d) # 报错，此时d已删除
{‘food’: ‘Spam’, ‘quantity’: ‘4’, ‘color’: ‘pink’}
{‘food’: ‘Spam’, ‘quantity’: ‘4’, ‘color’: ‘red’}
red
-------------------------------
None
键值不存在！
dict_keys([‘food’, ‘quantity’, ‘color’])
dict_values([‘Spam’, ‘4’, ‘red’])
dict_items([(‘food’, ‘Spam’), (‘quantity’, ‘4’), (‘color’, ‘red’)])
{}
集合
sample_set = {'Prince', 'Techs'}
print('Data' in sample_set) # 输出False，in的作用是检查集合中是否存在某一元素
# set.add(obj)：给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。
sample_set.add('Data') # 向集合中增加元素Data
print(sample_set) # 输出 {'Prince', 'Techs', 'Data'}
print(len(sample_set)) # 输出3
# set.remove(obj)：移除集合中的指定元素。
sample_set.remove('Data') # 删除元素Data
print(sample_set) # {'Prince', 'Techs'}
list2 = [1,3,1,5,3]
print(list(set(list2))) # 输出 [1,3,5]，利用集合元素的唯一性进行列表去重
sample_set = frozenset(sample_set)# 不可变集合
False
{‘Prince’, ‘Techs’, ‘Data’}
3
{‘Prince’, ‘Techs’}
[1, 3, 5]
深拷贝浅拷贝
import copy
Dict1 = { 'name': 'lee', 'age':89, 'num':[1,2,8]} # 新建字典
Dict_copy = Dict1.copy() # 浅拷贝
Dict_dcopy = copy.deepcopy(Dict1) # 深拷贝
Dict1['num'][1] = 6 # 修改原数据中嵌套列表的值
print('Dict1:'+str(Dict1)+"\n",' Dict_copy:'+ str(Dict_copy)+"\n",' Dict_dcopy:'+ str(Dict_dcopy))
Dict1:{‘name’: ‘lee’, ‘age’: 89, ‘num’: [1, 6, 8]}
Dict_copy:{‘name’: ‘lee’, ‘age’: 89, ‘num’: [1, 6, 8]}
Dict_dcopy:{‘name’: ‘lee’, ‘age’: 89, ‘num’: [1, 2, 8]}
if
# input()：用于接收输入。
score = input("请输入你的分数") # input函数接收输入，为字符串类型
score = float(score) # 将分数转化为数字类型
# try:… except Exception:… 是Python中用于捕获异常的语句，如果try中的语句出现错误，则会执行except中的语句。
try:
if 100>=score>=90: # 判断输入的值是否大于等级分数
print("优") # 满足条件后输出等级
elif 90 > score >= 80:
print("良")
elif 80>score>0:
print("中")
else:
print("差")
except Exception:
print("请输入正确的分数")
请输入你的分数100
优
循环
for i in range(1,10): #定义外层循环
for j in range(1,i+1):# 定义内层循环
# 字符串的格式化输出，让打印结果进行对齐，end属性设置打印结尾符号默认为/n
print("%d*%d=%2d"%(i,j,i*j), end=" ")
print()
11= 1
21= 2 22= 4
31= 3 32= 6 33= 9
41= 4 42= 8 43=12 44=16
51= 5 52=10 53=15 54=20 55=25
61= 6 62=12 63=18 64=24 65=30 66=36
71= 7 72=14 73=21 74=28 75=35 76=42 77=49
81= 8 82=16 83=24 84=32 85=40 86=48 87=56 88=64
91= 9 92=18 93=27 94=36 95=45 96=54 97=63 98=72 9*9=81
#while循环
i = 0 # 新建i变量
while i<9: # 设置循环条件
i+=1 # 每次循环i增加1
if i == 3: # 判断条件是否满足
print("跳出此次循环")
continue # continue跳出当前的这一次循环
if i == 5:
print("跳出当前大的循环")
break # 跳出当前的大的循环
print(i)
1
2
跳出此次循环
4
跳出当前大的循环
函数
def fibs(num): # 位置参数
result = [0,1] # 新建列表存储数列的值
for i in range(2,num): # 循环num-2次
a = result[i-1] + result[i-2]
result.append(a) # 将值追加至列表
return result # 返回列表
fibs(5)
[0, 1, 1, 2, 3]
def hello(greeting='hello',name='world'): # 默认参数
print('%s, %s!' % (greeting, name)) # 格式化输出
hello() # hello，world 默认参数
hello('Greetings') # Greetings，world 位置参数
hello('Greetings','universe') # Greetings，universe 位置参数
hello(name='Gumby') # hello，Gumby 关键字参数
hello, world!
Greetings, world!
Greetings, universe!
hello, Gumby!
对象
class Dog():
"""一次模拟小狗的简单尝试"""
def __init__ (self,name,age):
"""初始化属性name和age"""
self.name = name
self.age = age
def sit(self):
"""模拟小狗被命令时蹲下"""
print(self.name.title()+"is now sitting")
def roll_over(self):
"""模拟小狗被命令时打滚"""
print(self.name.title()+"rolled over!")
dog = Dog("哈士奇",2)
dog.sit()
dog.roll_over()
哈士奇is now sitting
哈士奇rolled over!
class Employee:
'所有员工的基类'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print("Total Employee %d" % Employee.empCount )
def displayEmployee(self):
print("Name : ", self.name, ", Salary: ", self.salary)
# 创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
# 创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print("Total Employee %d" % Employee.empCount)
Name : Zara , Salary: 2000
Name : Manni , Salary: 5000
Total Employee 2
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print("调用父类构造函数")
def parentMethod(self):
print('调用父类方法')
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print("父类属性 :", Parent.parentAttr)
class Child(Parent): # 定义子类
def __init__(self):
print("调用子类构造方法")
def childMethod(self):
print('调用子类方法')
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr()
调用子类构造方法
调用子类方法
调用父类方法
父类属性 : 200
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print(self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretCount) # 报错，实例不能访问私有变量
1
2
2
标准库
import sys
for i in range(100):
print(i)
if i ==5:
sys.exit(0)
0
1
2
3
4
5
An exception has occurred, use %tb to see the full traceback.
sys.path
sys.platform
[‘D:\python3.6\python36.zip’,
‘D:\python3.6\DLLs’,
‘D:\python3.6\lib’,
‘D:\python3.6’,
‘’,
‘D:\python3.6\lib\site-packages’,
‘D:\python3.6\lib\site-packages\IPython\extensions’,
‘C:\Users\zWX631096\.ipython’]
‘win32’
OS
import os
# os.getpid() 获取当前进程id
print("当前进程的ID：", os.getpid())
# os.getppid():获取当前父进程id
print("当前父进程的ID：", os.getppid())
# os.getcwd()：获取当前所在路径
cwd = os.getcwd()
print("当前所在路径为：",cwd)
# os.chdir(path)：改变当前工作目录
os.chdir("C:\\")
print("修改后当前所在路径为：", os.getcwd())
# os.listdir()：返回目录下所有文件
print("当前目录下的文件有：", os.listdir(cwd))
# os.walk()：输出当前路径下的所有文件
for root, dirs, files in os.walk(cwd, topdown=False):
for name in files:
print(os.path.join(root, name))
for name in dirs:
print(os.path.join(root, name))
当前进程的ID： 13304
当前父进程的ID： 7984
当前所在路径为： D:\python project\HCIA - AI实验
修改后当前所在路径为： C:
当前目录下的文件有： [‘.ipynb_checkpoints’, ‘ai.py’, ‘peiqi.py’, ‘text.txt’, ‘Untitled Folder’, ‘Untitled.ipynb’, ‘语音识别’]
D:\python project\HCIA - AI实验.ipynb_checkpoints\Untitled-checkpoint.ipynb
D:\python project\HCIA - AI实验\Untitled Folder.ipynb_checkpoints\Untitled-checkpoint.ipynb
D:\python project\HCIA - AI实验\Untitled Folder.ipynb_checkpoints\Untitled1-checkpoint.ipynb
D:\python project\HCIA - AI实验\Untitled Folder\Untitled.ipynb
D:\python project\HCIA - AI实验\Untitled Folder\Untitled1.ipynb
D:\python project\HCIA - AI实验\Untitled Folder.ipynb_checkpoints
D:\python project\HCIA - AI实验\语音识别\voice_dataset.zip
D:\python project\HCIA - AI实验\语音识别\yuyinchall.py
D:\python project\HCIA - AI实验\语音识别\yuyinutils.py
D:\python project\HCIA - AI实验\ai.py
D:\python project\HCIA - AI实验\peiqi.py
D:\python project\HCIA - AI实验\text.txt
D:\python project\HCIA - AI实验\Untitled.ipynb
D:\python project\HCIA - AI实验.ipynb_checkpoints
D:\python project\HCIA - AI实验\Untitled Folder
D:\python project\HCIA - AI实验\语音识别
import os
# os.path.abspath(path)：返回绝对路径
print("text.txt的绝对路径为：",os.path.abspath("text.txt")) # text.txt 为当前文件夹下的一个文件
# os.path.exists(path)：文件存在则返回True,不存在返回False
print("text.txt是否存在：",os.path.exists("text.txt"))
# os.path.getsize(path)：返回文件大小，如果文件不存在就返回错误
print("text.txt的文件大小：",os.path.getsize("text.txt"))
# os.path.isfile(path)：判断路径是否为文件
print("text.txt是否为文件：",os.path.isfile("text.txt"))
# os.path.isdir(path)：判断路径是否为文件夹
print("text.txt是否为文件夹：",os.path.isdir("text.txt"))
text.txt的绝对路径为： D:\python project\HCIA - AI实验\text.txt
text.txt是否存在： True
text.txt的文件大小： 4
text.txt是否为文件： True
text.txt是否为文件夹： False
Time
import time
# time.time():用于获取当前时间戳
time_now = time.time()
print("时间戳：",time_now)
# time.localtime()：获取时间元组
localtime = time.localtime(time_now)
print("本地时间为 :", localtime)
# time.asctime()：获取格式化的时间
localtime = time.asctime(localtime)
print("本地时间为 :", localtime)
#time.strftime(format[, t])：接收时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定。
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
时间戳： 1584886788.4408154
本地时间为 : time.struct_time(tm_year=2020, tm_mon=3, tm_mday=22, tm_hour=22, tm_min=19, tm_sec=48, tm_wday=6, tm_yday=82, tm_isdst=0)
本地时间为 : Sun Mar 22 22:19:48 2020
2020-03-22 22:19:48
IO
f = open("text.txt", 'w') # 打开文件text.txt，当文件不存在时会新建一个。
Str = input("请输入要写入的内容：")
f.write(Str)
f.close()
请输入要写入的内容：Python文件操作
f = open("text.txt", 'r')
print(f.read(6)) # 读取六个字符，当前光标后移六个字符
print(f.read()) # 读取光标所在位置至最后
f.close()
Python
文件操作
with open("text1.txt", 'w') as f:
f.write("python文件操作")
# 使用with语句读取文件内容
with open("text1.txt", 'r') as f:
print(f.read())
python文件操作
import os
os.rename("text.txt","text0.txt") # 文件重命名
os.remove("text1.txt") # 删除文件
多线程
import threading
from time import sleep,ctime
def work1():
for i in range(3):
print("work1正在执行...%d"%i)
sleep(1)
def work2():
for i in range(3):
print("work2正在执行...%d"%i)
sleep(1)
if __name__ == '__main__':
print('---开始---:%s'%ctime())
t1 = threading.Thread(target=work1)# 线程1
t2 = threading.Thread(target=work2)# 线程2
# 启动线程
t1.start()
t2.start()
sleep(5) #推迟执行的秒数
print('---结束---:%s'%ctime())
—开始—:Mon Mar 23 09:36:42 2020
work1正在执行…0
work2正在执行…0
work1正在执行…1work2正在执行…1
work1正在执行…2work2正在执行…2
—结束—:Mon Mar 23 09:36:47 2020
#“5s”
g_num = 0
def test1(num):
global g_num # 使用全局变量
for i in range(num):
mutex.acquire() # 上锁
g_num += 1
mutex.release() # 解锁
print("---test1---g_num=%d"%g_num)
def test2(num):
global g_num
for i in range(num):
mutex.acquire() # 上锁
g_num += 1
mutex.release() # 解锁
print("---test2---g_num=%d"%g_num)
# 创建一个互斥锁
# 默认是未上锁的状态，可以删除锁后查看资源争夺的结果
mutex = threading.Lock()
# 创建2个线程，让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()
p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()
# 等待计算完成
time.sleep(5)
print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)
—test2—g_num=1963943—test1—g_num=2000000
2个线程对同一个全局变量操作之后的最终结果是:2000000
多进程
from multiprocessing import Process
import os
import time
nums = [11, 22]
def work1():
"""子进程要执行的代码"""
print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))# 获取进程号
for i in range(3):
nums.append(i)
time.sleep(1)
print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
def work2():
"""子进程要执行的代码"""
print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))
if __name__ == '__main__':
p1 = Process(target=work1)
p1.start()
p1.join()
p2 = Process(target=work2)
p2.start()
迭代器
迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
可迭代对象：
以直接作用于 for 循环的数据类型有以下几种：
一类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；
一类是 generator ，包括生成器和带 yield 的generator function。
这些可以直接作用于 for 循环的对象统称为可迭代对象： Iterable 。
可以使用 isinstance() 判断一个对象是否是 Iterable 对象：
from collections import Iterable # 可迭代对象
print(isinstance([], Iterable))
print(isinstance('abc', Iterable))
print(isinstance(100, Iterable))
True
True
False
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
生成器都是 Iterator 对象，但 list 、 dict 、 str 虽然是 Iterable ，却不是 Iterator 。
把 list 、 dict 、 str 等 Iterable 变成 Iterator 可以使用 iter() 函数：
l = [1, 2, 3, 4, 5]
l_iter = iter(l)
next(l_iter)
next(l_iter)
2
from collections import Iterator # 迭代器
print(isinstance([], Iterator))
print(isinstance(iter([]), Iterator))
False
True
生成器
一边循环一边计算的机制，称为生成器
G = ( x*2 for x in range(5))
print(type(G))
def fib(n):
current = 0
num1, num2 = 0, 1
while current < n:
num = num1
num1, num2 = num2, num1+num2
current += 1
yield num
return 'done'
g=fib(5)
while True:
try:
x = next(g)
print("value:%d"%x)
except StopIteration as e:
print("生成器返回值:%s"%e.value)
break
value:0
value:1
value:1
value:2
value:3
生成器返回值:done
变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
def gen():
i = 0
while i<5:
temp = yield i
print(temp)
i+=1
f = gen()
next(f)
0
f.send('haha')
haha
1
next(f)
None
2
装饰器
import time
def func(f):
def inner(*args, **kwargs):
start_time = time.time()
f(*args, **kwargs)
end_time = time.time()
print('耗时：%s秒' % (end_time - start_time))
return inner
@func
def test():
time.sleep(2)
test()
耗时：2.0006320476531982秒
正则表达式
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none
import re
print(re.match('www', 'www.huawei.com').span()) # 在起始位置匹配
print(re.match('com', 'www.huawei.com')) # 不在起始位置匹配
(0, 3)
None
re.search 扫描整个字符串并返回第一个成功的匹配。
import re
line = "Cats are smarter than dogs"
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
if searchObj:
print("searchObj.group() : ", searchObj.group())
print("searchObj.group(1) : ", searchObj.group(1))
print("searchObj.group(2) : ", searchObj.group(2))
else:
print("Nothing found!!" )
searchObj.group() : Cats are smarter than dogs
searchObj.group(1) : Cats
searchObj.group(2) : smarter
re 模块提供了re.sub用于替换字符串中的匹配项。
import re
phone = "2019-0101-000 # 这是一个电话号码"
# 删除字符串中的 Python注释
num = re.sub(r'#.*$', "", phone)
print("电话号码是: ", num)
# 删除非数字(-)的字符串
num = re.sub(r'\D', "", phone)
print("电话号码是 : ", num)
电话号码是: 2019-0101-000
电话号码是 : 20190101000
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
import re
pattern = re.compile(r'\d+') # 用于匹配至少一个数字
n = pattern.match('one12twothree34four') # 查找头部，没有匹配
print(n)
m = pattern.search('one12twothree34four') # 从'e'的位置开始匹配，没有匹配
print(m)
print(m.group())
None
<_sre.SRE_Match object; span=(3, 5), match=‘12’>
12
split 方法按照能够匹配的子串将字符串分割后返回列表
import re
s = re.split('\W+', 'www.huawei.com')
print(s)
[‘www’, ‘huawei’, ‘com’]
变量
a='ABC'
- 内存中创建’ABC’的字符串
- 内存中创建a变量，指向’ABC’
变量a赋值给变量b，即把b指向a所指的数据。
格式化
- %
%d–整数；%f–浮点数；%s–字符串；%x–十六进制整数
%?–有几个占位符 - format()
用传入的参数依次替换字符串内的占位符{0}、{1}……
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'
- f-string
使用以f开头的字符串，字符串如果包含{xxx}，就会以对应的变量替换
>>> r = 2.5
>>> s = 3.14 * r ** 2
>>> print(f'The area of a circle with radius {r} is {s:.2f}')
The area of a circle with radius 2.5 is 19.62
#{r}被变量r的值替换，{s:.2f}被变量s的值替换，并且:后面的.2f指定了格式化参数
不可变对象
str不变对象，list可变对象
a=‘abc’ #a是变量，‘abc’是字符串对象，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
函数
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
from abstest import my_abs
#my_abs()的函数定义保存为abstest.py文件
Python的函数返回多值其实就是返回一个tuple
默认参数可以简化函数的调用：必选参数在前，默认参数在后；当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。（默认参数必须指向不变对象）
Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了
def add_end(L=[]):
L.append('END')
return L
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
#默认参数必须指向不变对象
#改进
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
- 函数可以定义可变参数，即传入的参数个数是可变的
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
#参数改为可变参数
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
# 在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：
- 关键字参数
允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
#函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数：
>>> person('Michael', 30)
name: Michael age: 30 other: {}
# 也可以传入任意个数的关键字参数：
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
# **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
如果要限制关键字参数的名字，就可以用命名关键字参数
def person(name, age, *, city, job):
print(name, age, city, job)
# 命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
#命名关键字参数必须传入参数名，可以有缺省值
#递归汉诺塔
def move(n,a,b,c):
if n==1:
print(a,'-->',c)
elif n>1:
move(n-1,a,c,b)
move(1,a,b,c)
#print(a,'-->',c)
move(n-1,b,a,c)
move(3, 'A', 'B', 'C')
生成器
如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator函数，调用一个generator函数将返回一个generator
调用该generator函数时，首先要生成一个generator对象，然后用next()函数不断获得下一个返回值。
在执行过程中，遇到yield就中断，下次又继续执行。
调用generator函数会创建一个generator对象，多次调用generator函数会创建多个相互独立的generator。
正确的写法是创建一个generator对象，然后不断对这一个generator对象调用next()
杨辉三角generator
def triangles():
L=[1]
yield L
while 1:
L=[1]+[L[i]+L[i+1] for i in range(len(L)-1)]+[1]
yield L
#print("w")
a = triangles()
for s in range(6):
print(next(a))
print(next(a))