Python基本功

任何工作，没别的，就是苦练基本功，在篮球场上，我常用非常简单的基本功就可以克敌制胜，工作中也是如此

字符串

1. 1：字符串拼接

a="'人民'"
b=123
print("我是"+a+""+str(b))
1
2
3

2：字符串格式化

year=1949
name='人民'
sport='站起来了'
print("%s中国%s从今以后%s "%(year,name,sport))
1
2
3
4

将数字进行了格式化，同时简单方便。

3. 3：字符串的格式化精度控制

!](https://img-blog.csdnimg.cn/45d6102a84504abfb97735abb07c9156.png)

a=12.456
print("%5.1f" %a)
1
2

#快速占位符
适合对精度没有要求的可以快速进行格式化

year='新年'
price='123'
print(f"你好{year},挣了{price}钱")
1
2
3

4. 对表达式格式化

数据输入

print("告诉我你是谁？")
name=input()
print(f"我知道了，你的名字是{name}")


name1=input("告诉我你的名字是什么？\n")
print(f"我知道了，你的名字是{name1}")
1
2
3
4
5
6
7

range

continue 和break的使用

break和continue生效范围是一样的，只是continue会继续执行
，详情可见下面两张图

Python函数

通过global关键字来修改

python数据容器

数据容器有以下特点
1：是否支持重复元素
2：是否可以修改
3：是否有序

分为5类，分别是list，元祖tuple，字符串str，集合set ，字典dict
容器的定义，一次性可以存储多个数据

list

1：存储的元素类型是不受限制的
2：列表里面再次嵌入列表叫作嵌套

如何取出数据
1：通过索引
正向下标，和反向下标
注意：不要超出索引范围。

列表的常用操作

name_list=['wang','liu']
print(name_list)
#查询
# 结果为0
print(name_list.index('wang'))
#输出异常，会断掉
#print(name_list.index('wan'))
#修改
name_list[0]='yao'
print(f"修改后的结果{name_list}")
#插入元素
#插入元素后，元素占据指定的位置
#['yao', 'ma', 'liu']
name_list.insert(1,'ma')
print(name_list)

#追加元素，是追加到元素的尾部
#['yao', 'ma', 'liu', 'xiao']
name_list.append('xiao')
print(name_list)
#第二种方法，使用extend将其他的列表追加到尾部
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'sun', 'li']
name_list2=["zhao","qian","sun","li"]
name_list.extend(name_list2)
print(name_list)

#元素的删除
#li 被删除
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'sun']
del name_list[7]
print(name_list)
#del仅仅能够删除元素，没法得到删除的值
name=name_list.pop(6)
#sun被删除
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian']
print(name_list)
#sun 可以得到一个返回值
print(name)

#删除元素的内容
#删除第一个元素
name_list.extend(name_list2)
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'zhao', 'qian', 'sun', 'li']
print(name_list)
name_list.remove('zhao')
#['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'zhao', 'qian', 'sun', 'li']
#第一个zhao被删除

#清空整个列表
name_list.clear()
#[] 得到了一个空列表
print(name_list)

#统计元素的数量
name_list=['yao', 'ma', 'liu', 'xiao', 'zhao', 'qian', 'zhao', 'qian', 'sun', 'li']
#1 得到了yao的数量
print(name_list.count('yao'))

#统计列表长度
#10
print(len(name_list))
#反转
name_list.reverse()
#['li', 'sun', 'qian', 'zhao', 'qian', 'zhao', 'xiao', 'liu', 'ma', 'yao']
print(name_list)

#列表的遍历
#两种方式可以获取到
def list_while_func():
    index=0
    while index < len(name_list):
        print(f"{name_list[index]}")
        index+=1
list_while_func()
def list_for_func():
    for i in name_list:
        print(i)
list_for_func()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

元组，

列表可以被修改，元组不可以被修改，只读的list

t=('zhang','liu','li','zhang','liu','li')
print(len(t)) #6
print(t.count('zhang')) #2
print(t.index('zhang')) #0
#不可以修改，（增加或者删除元素）
#支持for循环
#元组里面如果嵌套了list，那么是可以修改的
1
2
3
4
5
6
7

字符串

#字符串的操作
#字符串是不可修改的
my_str="happy days everyday"
#如下开始证明
#my_str[2]='H'
"""
Traceback (most recent call last):
  File "D:\code\python\venv\Scripts\5.py", line 5, in 
    my_str[2]='H'
TypeError: 'str' object does not support item assignment
"""

#查找特定的数据
print(my_str.index('days'))
#结果为6

#字符串的替换
#replace方法是得到了一个新的字符串，而不是修改了原来的字符串。
my_replace_str=my_str.replace('h','H')
#结果为happy days everyday
print(my_str)
#结果为Happy days everyday
print(my_replace_str)

#字符串的分割
#按照指定的分割字符串，将字符串划分为多个字符串，并入列表中，
#字符串本身不会变，而是得到了一个列表对象


my_str_list=my_str.split(" ")
#得到了这样的一个list，原来的并没有被改变
#['happy', 'days', 'everyday']
print(my_str_list)

my_str_strip=my_str.strip("h")
#只能对头和尾部进行操作
#appy days everyday
print(my_str_strip)

#统计字符串某个字符出现的次数
print(my_str.count('ay'))
#2

#查看长度
print(len(my_str))



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

切片操作

其他的如str和列表以及元组都支持切片，在这里不一一练习了

#序列的切片操作
#起始下标，结束下标，步长
#切片后会得到一个新的序列，并不会改变原来的
my_list=[1,2,3,4,5,6,7,8]

my_new_list=my_list[0:8:2]
#输出结果为[1, 3, 5, 7]
print(my_new_list)

my_tuple=(0,1,2,3,4,5,6)
my_new_tuple=my_tuple[-1:-6:-1]
#输出结果为(6, 5, 4, 3, 2)
print(my_new_tuple)
1
2
3
4
5
6
7
8
9
10
11
12
13

集合

#集合

#集合不支持重复元素
my_set={3,1,2,3,2,3,3}
#{1, 2, 3}
#内容是无序的，不支持下标索引访问，因为一旦发生改变，下标就会全部改变。序列的操作不支持集合，集合是允许修改的。
print(my_set)
#添加新元素

my_set.add(4)
#结果为{1, 2, 3, 4}
print(f"{my_set}")

#移除元素
my_set.remove(1)
{2, 3, 4}
print(my_set)


element=my_set.pop()
#随机取出一个
print(element)
#my_set的值也会发生改变
print(my_set)


#清空方法
my_set.clear()
set()
print(my_set)

my_set={3,1,2,3,2,3,3}

#取出差集

set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)
#查找到1里面有的，2里面没有的，set2和set1的结果不会发生变化
{2, 3}
print(set3)

#消除差集
#以集合1为标准，删除1和2里面相同的
print(f"取出集合1的值{set1}")
set1.difference_update(set2)
#将两者之间的1给删除掉{2, 3}
print(set1)
#集合2未发生变化{1, 5, 6}
print(set2)

#合并的功能
#{1, 2, 3, 5, 6}
print(set1.union(set2))



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

字典

#字典
#字典和集合非常像，集合不允许重复的。字典的key也是不允许重复的
my_dict1={"wang":"99","zhang":"66","gong":"77","liu":"44"}


#重复的key值只会存在一个
my_dict2={"wang":"79","wang":"99","zhang":"66","gong":"77","liu":"44"}

print(my_dict2)  #新的值会替换掉旧的{'wang': '99', 'zhang': '66', 'gong': '77', 'liu': '44'}


#获取key后面的值
print(my_dict1['wang'])  #99


#新增的key存在，就是新增，如果存在，就是更新
my_dict1['xiao']=78
print(my_dict1) #{'wang': '99', 'zhang': '66', 'gong': '77', 'liu': '44', 'xiao': 78}

#更新
my_dict1['xiao']=90
print(my_dict1) #{'wang': '99', 'zhang': '66', 'gong': '77', 'liu': '44', 'xiao': 90}

#删除
x=my_dict1.pop('xiao')
print(my_dict1) #{'wang': '99', 'zhang': '66', 'gong': '77', 'liu': '44'}
print(x) #90


#清空元素
my_dict1.clear()
print(my_dict1) #{}
#查看所有的key
print(my_dict2.keys())  #dict_keys(['wang', 'zhang', 'gong', 'liu'])

#遍历字典
for key in my_dict2.keys():
    print(my_dict2[key]) # 99
#66
#77
#44


#统计字典内的所有信息
print(my_dict2.items()) #dict_items([('wang', '99'), ('zhang', '66'), ('gong', '77'), ('liu', '44')])

print(len(my_dict2)) #4个元素



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

数据类型分类

数据容器的通用操作

#数据容器的通用操作-遍历
#都支持遍历操作，都支持len，max，min
#支持排序操作
my_list=[9,1,2,3,4,5,6,7]
my_set={9,1,2,3,4,5,6,7}

my_tuple=(3,1,2,5,4)
my_list.sort()
sorted(my_list)
sorted(my_tuple,reverse=True)
sorted(my_set)
print(my_set)
print(sorted(my_tuple))
#sorted是对内容进行排序，返回一个列表
#tuple因为具有不被修改的特性，所以不会被改变
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

函数的参数传递

#函数
#设置默认值参数得放在最后面
'''
def user_info(name,age,gender="男"):
    print(f"姓名是{name}，年龄是{age}，性别是{gender}")


user_info('wang',14)

#不定长，  位置不定长 *号
#不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数，
#作用：当调用参数时不确定参数个数时，可以使用不定长参数
'''
#不定长参数的类型
#位置传递，关键字传递
'''
'''
#第一种位置传递
def user_info(*args):
    print(args)
    return  args

#当使用不定长时，args默认会标记为元组，传递参数的时候会传递到元组里面去
a=user_info(18)
b=user_info('wang',18)
print(type(b))  #

#关键字传递的不定长
#数量也是不受限的，但同时也必须满足key=value的形式来让keyargs来接受
def user_info1(**kwargs):
    print(kwargs)
    return kwargs
a=user_info1(name='wang',id=112,age=18) #{'name': 'wang', 'id': 112, 'age': 18}
print(type(a)) #
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

lambda函数

#关键字传递的不定长
#数量也是不受限的，但同时也必须满足key=value的形式来让keyargs来接受
def user_info1(**kwargs):
    print(kwargs)
    return kwargs
a=user_info1(name='wang',id=112,age=18) #{'name': 'wang', 'id': 112, 'age': 18}
print(type(a)) #


#匿名函数 就是没有名称
#有名称的函数，可以基于名称重复使用。无名称的函数，只能临时使用一次
#使用场景见如下
#lambda 传入参数：函数体
my_list=[1,2,3,4]
def test(x):
    result=x(2)
    return result


#print(test(my_list[2]))TypeError: 'int' object is not callable
print(test(lambda x:x*2))#test里面的参数必须得是一个函数的地址 #总结lamdba使用的本质为将函数的地址传递给另外一个函数。非常简单好用
#lambad函数提升了一些应用场景，简洁明了
#如果该函数如果需要使用多次，那么就用def，只使用一次就用lambda
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

异常

#Python异常操作
'''
try :
可能发生错误的代码
except：
如果出现异常执行的代码，如果出现异常，到except里面去执行
else：
如果没有异常，就执行这一步
finally
无论有没有异常，100%都要执行
异常也会进行传递，
'''


try:
    f=open("linux.txt","r",encoding="UTF-8")
except: #出现异常了，被except接收
    print("出现异常了，文件不存在,改为W模式去打开")
    f = open("linux.txt", "w", encoding="UTF-8")


try:
     print(name)
except NameError as e:
    print(e)  #name 'name' is not defined
    print("出现了变量未定义")

#捕获多个异常
try:
    print(1/0)
except (NameError,ZeroDivisionError): #通过元组将异常捕获
    print('错误')

#如果未能设置正确的异常类型，那么会无法捕获
#捕获全部的异常
try:
    1/0
except Exception as e: #通过捕获Exception来达到捕获全部的目标，这是通常情况下的写法 Exception是顶级的异常，其他的异常都是
    print('异常出现了')


#异常的else：

try:
    a=2
    print(a)
except:
    print('有异常')
else:
    print("没有异常")
finally:
    print("你好")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

模块

#模块的导入
#导入Python内置的模块
#模块就是一个工具包
#中括号表示可选项目[from 模块名]import[模块|类|变量|函数][as 别名]
"""
#import 模块名
import time
time.sleep(5)
print(time.altzone)

#import是直接把所有功能代入，from 是只使用部分功能
from time import sleep
#通过 from这种方式，只能使用sleep
print("你好")
sleep(5)#和import的写法就不一样了，可以只写sleep了,如果只写import，那么必须得加上time
print("你好")
"""
#from time import *

# print("你好")
# sleep(5)#通过这种形式也可以再前面不加time
# print("好")

# import time as t
# #在同一个文件夹下直接引用就行了
# import my_module1
# print("你好")
# t.sleep(5)
# print("hello")
# my_module1.test(1,2)
#
# from time import sleep as sl
#
# print("a")
# sl(5)
# print("b")
#在同一个文件夹下直接引用就行了
# import my_module1
# # my_module1.test(1,2)
# # #第二种引用方式
from my_module1 import  *

test_A()
#test_B()  #NameError: name 'test_B' is not defined,由于有了__all__变量的产生，导致了
#如果要想单独引用，那么必须得如下操作
from my_module1 import  test_B
test_B()


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

Python 包

在pycharm上直接创建就行了

封装

"""
封装（将现实世界事物在类中描述为属性和方法，即为封装）
    私有成员：
        定义私有成员变量或者方法，只需要变量名或者方法名以__开头（2个下划线） 
        类对象无法访问私有成员，类中的其他成员可以访问私有成员
"""


# 演示面向对象封装思想中私有成员的使用
class Phone:
    __current_voltage = 0.5  # 当前手机运行电压（对用户隐藏）

    def __keep_single_core(self):
        print("让CPU以单核模式运行")

    def call_by_5g(self):  # 手机进入5g模式
        if self.__current_voltage >= 1:
            print("5g通话已开启")
        else:
            self.__keep_single_core()
            print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")


phone = Phone()
# print(phone.__current_voltage)  # 直接调用私有变量，报错
# phone.__keep_single_core()      # 直接调用私有方法，报错
phone.call_by_5g()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

继承

"""
继承（从父类哪里继承来成员变量和成员方法，但不含私有）
    继承语法如下：
        class 类名（父类1,父类2,父类3,...）：
            类内容体
"""


# 演示继承
class Phone:
    IMEI = None  # 序列号
    producer = "HM"  # 厂商

    def call_by_4g(self):
        print("4g通话")


class Phone2022(Phone):
    face_id = "10001"  # 面部识别ID

    def call_by_5g(self):
        print("2022年新功能：5g通话")


phone = Phone2022()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

复写

"""
    复写(如果要复写父类属性或者方法，只需要在子类中重新定义即可)
        如果需要调用被复写的父类的成员:
            方法1：
                父类名.成员变量
                父类名.成员方法（self）
            方法2(使用super())：
                super().成员变量
                super().成员方法()
                
"""

1
2
3
4
5
6
7
8
9
10
11
12

多态

#多态
"""
多态：多态指的是多种状态，即完成某个行为(函数)时，使用不同的对象会得到不同的状态
在这里有一个和重写的区别，重写是方法，自己的对象调用自己的方法，而多态是对象的使用，
    1.主要作用在继承关系上（抽象类，即接口,用于顶层设计作为约束，子类做具体实现）：
        父类做声明工作
        以子类做实际工作
        用以获得同一行为，不同状态
"""
"""
演示面向对象的多态特性
"""
class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

class Cat(Animal):
    def speak(self):
        print("喵喵喵")

def make_noise(animal: Animal):
    # 制造噪音，需要传入Animal对象
    animal.speak()

# 演示多态，使用两个子类对象来调用函数
dog = Dog()
cat = Cat()
make_noise(dog)  # 汪汪汪 对对象的调用，完成了多态
make_noise(cat)   #喵喵喵 同样的行为出现不同的状态，多态都使用在抽象类的场景

"""
演示抽象类(接口)的使用
抽象类用于顶层设计，具体使用
"""
class AC:
    def cool_wind(self):
        """制冷"""
        pass

    def hot_wind(self):
        """制热"""
        pass

    def swing_l_r(self):
        """左右摆风"""
        pass

#从下面可以看到，多态长应用于抽象类和抽象方法
class Midea_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")

    def hot_wind(self):
        print("美的空调制热")

    def swing_l_r(self):
        print("美的空调左右摆风")


class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")

    def hot_wind(self):
        print("格力空调制热")

    def swing_l_r(self):
        print("空调左右摆风")


def make_cool(ac: AC):
    ac.cool_wind()


midea_ac = Midea_AC()
gree_ac = GREE_AC()

make_cool(midea_ac)
make_cool(gree_ac)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

闭包和装饰器

#闭包的作用
#全局变量有被修改的风险，代码在命名空间上不够干净整洁
#第一种，不使用闭包的场景
account_amount=0
def atm(num,deposit=True):
    global account_amount
    if deposit:
        account_amount+=num
        print(f"存款：+{num}，账户余额{account_amount}")
    else:
        account_amount-=num
        print(f"存款：-{num}，账户余额{account_amount}")
atm(300) #存款：300，账户余额300
atm(300) #存款：300，账户余额600
atm(100,False) #存款：100，账户余额500
#从上面可以看到全局变量在被不断的修改，同时，代码也不够干净

#使用闭包的写法见如下,这种就不会有全局变量了，这种就是闭包了
def account_create(initial_amount=0):
    def atm(num,deposit=True):
        nonlocal initial_amount #这条句子定义后，后续可以在修改变量
        if deposit:
            initial_amount+=num
            print(f"存款+{num}，账户余额{initial_amount}")
        else:
            initial_amount-=num
            print(f"存款-{num}，账户余额{initial_amount}")
    return atm
fn=account_create()
fn(100)  #存款+100，账户余额100
fn(200)  #存款+200，账户余额300

#闭包的优点 无需要定义全局变量就可以通过函数，持续的访问修改某个值，闭包使用的变量在于函数内，难被错误的调用修改
#缺点，由于内部持续引用外包函数的值，所以会导致内存空间不足，一直占用内存

# 装饰器的一般写法（闭包）
def outer(func):
    def inner():
        print("我要睡觉了")
        func()
        print("我要起床了")
        return None

    return inner


def sleep():
    import random
    import time
    print("睡眠中。。。")
    time.sleep(random.randint(1, 5))
    return None

fn = outer(sleep)
fn()

# 装饰器的快捷写法
def outer(func):
    def inner():
        print("我要睡觉了")
        func()
        print("我要起床了")
        return None

    return inner


@outer
def sleep():
    import random
    import time
    print("睡眠中。。。")
    time.sleep(random.randint(1, 5))
    return None


sleep()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78