Python基础语法-day1

照旧的你好

已于 2023-04-07 20:41:19 修改

阅读量4.8k

点赞数 1

分类专栏： python 文章标签： python 开发语言 numpy

于 2020-05-18 16:38:40 首次发布

本文链接：https://blog.csdn.net/weixin_43769170/article/details/105034394

版权

python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

数值

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)

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)

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))

照旧的你好

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
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) ...
复制链接

扫一扫