Python基础知识

判断语句和循环结构

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("请输入正确的分数")

循环语句

#while循环
i = 0          # 新建i变量
while i < 9:     # 设置循环条件
    i += 1       # 每次循环i增加1
    if i == 3: # 判断条件是否满足
        print("跳出此次循环")
        continue # continue跳出当前的这一次循环
    if i == 5:
        print("跳出当前大的循环")
        break # 跳出当前的大的循环
    print(i)

函数和类

函数

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   # 返回列表
print(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    关键字参数

类

class Greeter(object):        # 新建类，继承object
    def __init__(self, name): # 初始化类
        self.name = name      # 创建一个实例变量
        
    # 实例方法
    def greet(self, loud=False):
        if loud:
            print('HELLO, %s!' % self.name.upper())
        else:
            print('Hello, %s' % self.name)
g = Greeter('Fred')     # 创建Greeter类的一个实例
g.greet()               # Hello,Fred    调用实例方法，使用默认参数
g.greet(loud = True)    # HELLO, FRED  调用实例方法，自定义参数

文件操作

# 使用write方法写文件
with open("f.txt", "w") as f:
    f.write( "www.huawei.com")

# 使用read方法读取
with open("f.txt", "r") as f:
    print(f.read())

Python 高级

多线程

• 线程（Thread）也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。
• 线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。
• 一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行

import threading  #导入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())
---开始---:Fri Jul 23 09:30:33 2021

import threading
import time
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)

正则表达式

• 正则表达式是一个很强大的字符串处理工具，几乎任何关于字符串的操作都可以使用正则表达式来完成。

import re  #导入正则表达式模块
print(re.match('www', 'www.huawei.com').span())  # 在起始位置匹配
print(re.match('com', 'www.huawei.com'))        	# 不在起始位置匹配

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

import re 
phone = "2019-0101-000 # 这是一个电话号码"

# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone)
print("电话号码是: ", num)

# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print("电话号码是 : ", num)

import re
pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
n = pattern.match('one12twothree34four')        # 查找头部，没有匹配
print(n)

m = pattern.search('one12twothree34four') # 从'e'的位置开始匹配，没有匹配
print(m)
print(m.group())

import re
s = re.split('\W+', 'www.huawei.com') #切分字符串
print(s)

魔法方法

• 魔法方法是python内置方法，不需要主动调用，存在的目的是为了给python的解释器进行调用，几乎每个魔法方法都有一个对应的内置函数，或者运算符，当我们对这个对象使用这些函数或者运算符时就会调用类中的对应魔法方法，可以理解为重写这些python的内置函数。

class Dog(object):  #定义一个类
    def __init__(self, name):
        self.name = name 
        print("小狗：%s"%(self.name))
        
dog = Dog("dog")

class Dog(object):
    def __init__(self, name):
        self.name = name
        
    def __str__(self):
        return "小狗的名字："+self.name
dog = Dog("dog")
print(dog)

class Dog(object):
    def __init__(self, name):
        self.name = name
        
    def __str__(self):
        return "小狗的名字："+self.name
    
    def __repr__(self):
        return "这是小狗%s的对象"%(self.name)
dog = Dog("dog")
dog