一 基本数据类型

Python 默认拥有以下内置数据类型：

数据类型的转换

字符串方法

二 python运算符

• 算术运算符

  1 2 3 4 5 6 7 8 9 10

  a = 10 b = 3 print(a + b) # 13 加法 print(a - b) # 7 减法 print(a * b) # 30 乘法 print(a / b) # 3.333... 除法 print(a // b) # 3 整除 print(a % b) # 1 取模 print(a ** b) # 1000 幂运算

• 赋值运算符

  1 2 3 4 5

  a = 5 a += 2 # 等同于 a = a + 2 → 7 a -= 1 # 6 a *= 3 # 18 a /= 2 # 9.0

• 比较运算符

  1 2 3 4 5 6

  print(a == b) # 等于 print(a != b) # 不等于 print(a > b) # 大于 print(a < b) # 小于 print(a >= b) # 大于等于 print(a <= b) # 小于等于

• 逻辑运算符

  1 2 3 4 5

  x = True y = False print(x and y) # False 与 print(x or y) # True 或 print(not x) # False 非

• 成员运算符

  1 2 3

  pytcolors = ['red', 'green', 'blue'] print('red' in colors) # True print('yellow' not in colors) # True

• 身份运算符

  1 2 3 4 5 6 7 8

  a = [1, 2, 3] b = a # b引用同一个列表对象 c = [1, 2, 3] # c创建了一个新列表对象 print(a == b) # True - 值相同 print(a is b) # True - 是同一个对象 print(a == c) # True - 值相同 print(a is c) # False - 不是同一个对象

• 位运算符

  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时，结果才为1 a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 print(a & b) # 12 = 0000 1100 | 两个位有一个为1时，结果就为1 a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 print(a | b) # 61 = 0011 1101 ^ 个位不同时结果为1，相同时为0 a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 print(a ^ b) # 49 = 0011 0001 ~ 所有位取反（包括符号位） a = 60 # 60 = 0011 1100 print(~a) # -61 = 1100 0011 << 所有位向左移动，右侧补0 a = 5 # 5 = 0000 0101 print(a << 1) # 10 = 0000 1010 print(a << 2) # 20 = 0001 0100 >> 所有位向右移动，左侧补符号位 a = 10 # 10 = 0000 1010 b = -10 # -10 = 1111 0110 (补码表示) print(a >> 1) # 5 = 0000 0101 print(b >> 1) # -5 = 1111 1011

三python集合数据类型

Python 编程语言中有四种集合数据类型：
列表（List）是一种有序和可更改的集合。允许重复的成员。
元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。
集合（Set）是一个无序和无索引的集合。没有重复的成员。
词典（Dictionary）是一个无序，可变和有索引的集合。没有重复的成员。

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

# 创建列表
fruits = ['apple', 'banana', 'cherry']
numbers = [1, 2, 3, 4, 5]

# 访问元素
print(fruits[0])   # apple
print(fruits[-1])  # cherry (最后一个元素)

# 切片操作
print(numbers[1:3])  # [2, 3]
print(numbers[:3])   # [1, 2, 3]
print(numbers[2:])   # [3, 4, 5]

# 修改列表
fruits[1] = 'blueberry'  # 修改元素  ['apple', 'blueberry', 'cherry']
fruits.append('orange')  # 添加元素  ['apple', 'banana', 'cherry','orange']
fruits.insert(1, 'mango')  # 在指定位置插入  ['apple','mango', 'banana', 'cherry']
fruits.remove('apple')  # 删除元素
popped = fruits.pop()   # 删除指定的索引（如果未指定索引，则删除最后一项）
del fruits[0]           # del 关键字删除指定的索引：
fruits.clear()          # clear() 方法清空列表：
fruits.copy()           # 使用 copy() 方法来复制列表

# 列表操作
combined = fruits + numbers  # 列表拼接
fruits.extend(numbers)       # 使用 extend() 方法将 list2 添加到 list1 的末尾：
repeated = numbers * 2       # 列表重复 
thislist = list(("apple", "banana", "cherry")) #  使用 list() 构造函数创建列表：

# 列表推导式
squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 创建元组(不可变)
colors = ('red', 'green', 'blue')
single = (42,)  # 单元素元组需要逗号

# 访问元素
print(colors[1])  # green

# 更改元组
将元组转换为列表，更改列表，然后将列表转换回元组。
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x)
tuple3 = tuple1 + tuple2     # 合并元组
thistuple = tuple(("apple", "banana", "cherry")) # tuple() 构造函数来创建元组。
# 删除项目
thistuple = ("apple", "banana", "cherry")
del thistuple

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

# 创建集合(无序且不重复)
unique_numbers = {1, 2, 3, 3, 4}
print(unique_numbers)  # {1, 2, 3, 4}

# 集合操作
a = {1, 2, 3}
b = {2, 3, 4}

print(a | b)  # 并集 {1, 2, 3, 4}
print(a & b)  # 交集 {2, 3}
print(a - b)  # 差集 {1}
print(a ^ b)  # 对称差集 {1, 4}

# 更改集合
thisset = {"apple", "banana", "cherry"}

thisset.add("orange")      # 将一个项添加到集合，使用 add() 方法。
thisset.update(["orange", "mango", "grapes"]) # 使用 update() 方法将多个项添加到集合中：
thisset.remove("banana") # 使用 remove() 方法来删除 “banana”：
thisset.discard("banana") # 使用 discard() 方法来删除 “banana”：  
thisset.clear()    # clear() 方法清空集合：
del thisset         #del 彻底删除集合：
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set1.update(set2)      # update() 方法将 set2 中的项目插入 set1 中：
set3 = set1.union(set2) # union() 方法返回一个新集合，其中包含两个集合中的所有项目：

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

# 创建字典
person = {
    'name': 'Alice',
    'age': 25,
    'city': 'New York'
}

# 访问元素
print(person['name'])  # Alice
print(person.get('age'))  # 25
print(person.get('country', 'USA'))  # 如果键不存在，返回默认值'USA'

# 修改字典
person['age'] = 26  # 更新值
person['country'] = 'USA'  # 添加新键值对
del person['city']  # 删除键值对

# 字典操作
print('name' in person)  # True 检查键是否存在
print(person.keys())    # 所有键
print(person.values())  # 所有值
print(person.items())   # 所有键值对

四条件语句

1
2
3
4
5
6
7
8
9

# if语句
age = 18

if age < 18:
    print("未成年人")
elif age >= 18 and age < 60:
    print("成年人")
else:
    print("老年人")

五循环语句

• while循环
  只要条件为真，就可以执行一组语句。
  break 语句，即使 while 条件为真，也可以停止循环：
  如果使用 continue 语句，我们可以停止当前的迭代，并继续下一个：
  通过使用 else 语句，当条件不再成立时，我们可以运行一次代码块

  1 2 3 4 5 6 7

  # while循环 count = 0 while count < 5: print(count) count += 1 else: print("循环结束")

• for 循环

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

  # for循环 fruits = ['apple', 'banana', 'cherry'] for fruit in fruits: print(fruit) # 使用range for i in range(5): # 0到4 print(i) for i in range(2, 6): # 2到5 print(i) for i in range(1, 10, 2): # 1开始，步长为2，到9 print(i)

六函数

在 Python 中，使用 def 关键字定义函数：

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

def my_function():
  print("Hello from a function")

my_function()


def my_function(fname):
  print(fname + " Gates")

my_function("Bill")
my_function("Steve")
my_function("Elon") 

# 以 List 传参
def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

# 关键字参数
def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")

# 任意参数
def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Phoebe", "Jennifer", "Rory")

七 匿名函数

python 使用 lambda 来创建匿名函数

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

基本语法

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

lambda [arg1 [,arg2,.....argn]]:expression

# -*- coding: UTF-8 -*-

sum = lambda num1 , num2 : num1 + num2;

print( sum( 1 , 2 ) )

输出结果：3


lambda 表达式中的 num2 是一个自由变量，在运行时绑定值，而不是定义时就绑定，这跟函数的默认值参数定义是不同的。
# -*- coding: UTF-8 -*-

num2 = 100
sum1 = lambda num1 : num1 + num2 ;

num2 = 10000
sum2 = lambda num1 : num1 + num2 ;

print( sum1( 1 ) )
print( sum2( 1 ) )

输出结果  
10001
10001

八 类和对象

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

创建类
class Myclass:
    def _init_(self, name, age):
        self.name=name
        self.age=age
p1=Myclass("lii",63)
print(p1.name)
print(p1.age)

# 对象方法
class Myclass:
    def _init_(self, name, age):
        self.name=name
        self.age=age
    def myfun():
        print("my name is"+self.name)
p1=Myclass("bili",63)
p1.myfun()


--------------------------------------------------------------
class ClassA():
    var1 = 100
    var2 = 0.01
    var3 = '两点水'

    def fun1():
        print('我是 fun1')

    def fun2():
        print('我是 fun1')

    def fun3():
        print('我是 fun1')
上面我们就定义了一个类，类名叫做 `ClassA` , 类里面的变量我们称之为属性，那么就是这个类里面有 3 个属性，分别是 `var1` , `var2` 和 `var3` 。除此之外，类里面还有 3 个类方法 `fun1()` , `fun2()` 和 `fun3()` 。

封装

将复杂的流程包起来，内部处理，让使用者只需要通过简单的操作步骤，就能实现。指的是隐藏对象中一些不希望外界所访问到的属性或者方法

• 隐藏属性：只允许在类的内部使用
  在属性名或者方法名前加两个下划线

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  class person: name="jame" __age=28 p=person() print(p.name) print(p.age) 此时会报错。age是隐藏属性 第一种访问方法 此时age名称其实被改为 _person__age print(p._person__age) #此时即可访问 第二种访问方法：内部访问 class person: name="jame" __age=28 def age(self): person.__age=18 print(f"{person.name}的年龄为{person.__age}") p=person() print(p.name) p.age()

• 私有属性
  单下划线开头，外部可使用，但是通过import from 无法导入

九继承

继承允许我们定义继承另一个类的所有方法和属性的类。

父类是继承的类，也称为基类。

子类是从另一个类继承的类，也称为派生类。

9.1创建父类

1
2
3
4
5
6
7
8
9

class person:
    def _init_(self,fname,lname):
        self.firstname=fname
        self.lastname=lname
    def printname(self):
        print(self.firstname,self.lastname)
        print(self.age)
x=person("gate","bill")
x.printname()

9.2创建子类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Person:
    def _init_(self,fname,lname):
        self.firstname=fname
        self.lastname=lname
    def printname(self):
        print(self.firstname,self.lastname)
        print(self.age)

class Student(Person):
    pass
    def __init__(self, fname, lname): # 添加 __init__() 函数
# 当添加 __init__() 函数时，子类将不再继承父的 __init__() 函数。
# 如需保持父的 __init__() 函数的继承，请添加对父的 __init__() 函数的调用：
    person._init_(self,fname,lname)
# Python 还有一个 super() 函数，它会使子类从其父继承所有方法和属性：
     super().__init__(fname, lname)
x=Student("gate","bill")
x.printname()

9.3单继承

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

class Father:
    def eat(self):
        print("吃饭")
    def sleep(self):
        print("睡觉")
class son(Father):
    pass
class Grandson(son):
    pass
# son=son()
# son.sleep()
grand=Grandson()
grand.sleep()   # 输出睡觉

9.4方法的重写（在子类定义与父类相同名称的方法）

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

class Father:
    def money(self):
        print("100万需要继承")

class Man(Father):
    def money(self):
        Father.money(self)
        super().money()
        print("自己再赚")

man=Man()
man.money()

9.5多继承

多个父类具有同名属性，遵循就近原则

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

class Father:
    def money(self):
        print("100万需要继承")
class Mother:
    def apperance(self):
        print("120万需要继承")
        print("美貌")
class Son(Father,Mother):
    pass
son=Son()
son.money()
son.apperance()

9.6多态

同一种行为具有不同的表现形式

1. 继承
2. 重写

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

   class Animal: """父类""" def shout(self): print("动物会叫") class Cat(Animal): """子类 猫""" def shout(self): print("喵喵") class Dog(Animal): def shout(self): print("汪汪汪") cat=Cat() cat.shout() dog=Dog() dog.shout()

3. 多态性：一种调用方式，不同的执行结果

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   class Animal(object): """父类""" def eat(self): print("动物会吃") class Pig(Animal): """子类 猪""" def eat(self): print("猪吃饲料") class Dog(Animal): def eat(self): print("狗吃狗粮") def text(obj): #obj形参 obj.eat() animal=Animal() pig=Pig() dog=Dog() text(animal) text(pig) text(pig)

   9.7静态方法 / 类方法

   静态方法没有self,cls参数限制
   静态方法不能访问实例属性

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   class Person(object): @staticmethod #静态方法 def study(name): print(f"{name}会学习") Person.study("张三") p=Person() p.study("张三") 类方法不能访问到实例属性 # 使用@classmethod标识为类方法。 # 第一个参数必须是类对象 class Person(object): @classmethod def sleep(cls): print("睡觉") print(cls) # 类对象本身 Person.sleep()

十单例模式和魔法方法

10.1 init()和 new()

1. init():
   初始化对象
2. new():
   new()： object基类体提供的内置的静态的方法 —创建对象
   作用1：再内存中为对象分配空间，2，返回对象的引用

10.2单例模式

优点：可以节省内存空间
弊端：多线程访问的时容易引发多线程安全问题

10.2.1方式

1通过@classmethod

2通过装饰器实现

3通过重写new()实现

设计流程

1. 定义一个类属性，初始值为None
2. 重写new()方法
3. 进行判断，如果属性是None,把new()对象返回的对象引用保存进去

   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

   class A(object): pass a1=A() a2=A() print(a1) print(a2) # 内存地址 # <__main__.A object at 0x000002AC75A3B9D0> # <__main__.A object at 0x000002AC75A39DE0> 此时内存地址不同 #单例模式对象的内存地址都一样，只有一个对象 class sing(object): obj=None def __new__(cls, *args, **kwargs): print("我new属性") if cls.obj==None: cls.obj=super().__new__(cls) return cls.obj def __init__(self): print("我是__init__()") s=sing() print(s) s1=sing() print(s1) 此时内存地址都是同一个

   4返回类属性中记录的对象引用。

   5通过导入模块实现

十一迭代器

列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。

所有这些对象都有用于获取迭代器的 iter() 方法：

• 从元组返回一个迭代器，并打印每个值：

  1 2 3 4 5 6 7 8 9 10 11

  mytuple = ("apple", "banana", "cherry") myit = iter(mytuple) print(next(myit)) print(next(myit)) print(next(myit)) for 循环实际上创建了一个迭代器对象，并为每个循环执行 next() 方法。 mystr = "banana" for x in mystr: print(x)

  创建迭代器

  要把对象/类创建为迭代器，必须为对象实现 iter() 和 next() 方法。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  class Mymunber: def __iter__(self): self.a=1 return self def __next__(self): x=self.a self.a+=1 return x myclass=Mymunber() it=iter(myclass) print(next(it)) print(next(it)) print(next(it)) print(next(it)) print(next(it)) 输出 1 2 3 4 5

  十二 生成器

  生成器表达式

  生成器函数

  python中使用了yield关键字的函数就称之为生成器函数
• yield的作用
  类似return 将指定值或者多个值返回给调用者
  yield语句一次返回一个结果，再每个结果中间，挂其函数，执行next()

  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

  def gen(): print("开始了") yield "a" yield 'b' g=gen() print(next(g)) print(next(g)) # print(next(g)) # print(next(g)) def gen(n): li=[] # for i in range(n): # li.append(i) a=0 while a<n: li.append(a) a+=1 print(li) gen(7) def gen(n): li=[] a=0 while a<n: li.append(a) # print(a) yield a # print(a) a+=1 print(li) for i in gen(5): print(i)

  十三线程

  多线程

  线程：是cpu调度的基本单位，每一个进程至少会有一个线程
  进程：是操作系统进行资源分配的基本单位

  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

  import time import threading # target: 执行的任务 没有小括号 # args: 以元组的形式传参 # kwarfs: 以字典的形式给任务传参 def sing(name): print(f"{name}唱歌") time.sleep(2) print("唱完了") def dance(name2): print(f"{name2}跳舞") time.sleep(2) print("跳完了") # 主程序入口 if __name__=='__main__': #创建子线程 t1=threading.Thread(target=sing,args=("张三",)) #以元组形式传参,只有一个元素后面加逗号 t2=threading.Thread(target=dance,args=("李四",)) # print(t1) # 守护线程 主线程执行结束,子线程也会跟着结束 t1.daemon=True t2.daemon=True #开启子线程 t1.start() t2.start() # 阻塞主线程join():暂停的作用,等子线程执行结束后,主线程才会继续执行 t1.join() t2.join() # 获取线程名字 print(t1.name) print(t2.name) #更改线程名 t1.name="子线程一" t2.name="子线程二" print(t1.name) print(t2.name) print("表演结束")

  多线程的特点

1. 多线程之间执行是无序的
2. 线程之间资源共享
3. 资源竞争

   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 线程阻塞 # 2 互斥锁 a=0 b=1000000 lock=threading.Lock() def add(): lock.acquire() # 加锁 for i in range(b): global a a=a+1 print("第一次:",a) lock.release() #解锁 def add2(): lock.acquire() for i in range(b): global a a=a+1 print("第二次:",a) lock.release() # add() # add2() if __name__=='__main__': first=threading.Thread(target=add) second=threading.Thread(target=add2) first.start() # first.join() second.start()

   十四进程

   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

   # 进程不共享全局变量 # multiprocessing模块提供了process类代表进程对象 # process参数 # 1. target:执行任务目标名 # 2. args:以元组形式传参 # 3. kwargs:以字典形式传参 # 方法 # 1. start() # 2. is alive() 判断进程是否存活 # 3. join() 主进程等待子进程执行结束 # 属性 # 1. name: 当前进程的别名 # 2. pid: 当前进程编号 def sing(): print("子进程编号",os.getpid(),"父进程",os.getppid()) print("唱歌") def dance(): print("子进程编号", os.getpid(), "父进程", os.getppid()) print("跳舞") if __name__=='__main__': p1=multiprocessing.Process(target=sing,name="子进程1") p2=multiprocessing.Process(target=dance,name="子进程2") # 开启 p1.start() p2.start() print(p1.name) print(p2.name) print(p1.pid) print(p2.pid) print("主进程编号",os.getpid(),"主进程的父进程:",os.getppid()) """ 子进程1 子进程2 42116 39392 主进程编号 11908 主进程的父进程: 40648 子进程编号 42116 父进程 11908 唱歌 子进程编号 39392 父进程 11908 跳舞 """

   进程间的通信

   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

   put():放入数据 get():取出数据 empty():判断队列是否为空 qsize():返回当前队列包含的消息 full():判断队列是否满了 # from queue import Queue # 初始化一个队列 from multiprocessing import Process,Queue # from queue import Queue # 初始化一个队列 # q=Queue() #最多可接受3条消息 # q.put("123") # q.put("456") # q.put("789") # print(q.get()) # print(q.get()) # print(q.get()) # print(q.empty()) li=["张三","李四"] def wdate(q): for i in range(5): print(f"{i}已经放入") q.put(i) print("写入的数据",li) def rdate(q): while True: if q.empty(): break else: print("取出数据",q.get()) # print("读取的数据",li) if __name__=='__main__': q=Queue() p1=Process(target=wdate,args=(q,)) p2 = Process(target=rdate,args=(q,)) p1.start() p1.join() p2.start()