python基础

python设计目标

  • 一门简单直观的语言，与主要竞争者一样强大
  • 开源，任何人都可以做贡献
  • 代码像纯英语那样好理解
  • 适用于短期开发的日常任务

Hello World

1
print("hello world")

变量

1
2
3
4
qq_number = '10086'
qq_password = '10001'
print(qq_number)
print(qq_password)

函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#print 输出日志
print("输出日志")

#type 查看变量类型
num = 10
type(num) 
print(type(num))#class int

#input 输出键盘内容
qq_number = input("请输入账号：")
qq_password = input("请输入密码: ")

#int 转换类型为整数
str = "10086"
num = int(str) 
print(num)#10086 

#转换类型为小数
str_two = "100.86"
num = float(str_two)#100.86

bool
...

练习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#租房
rent_oneday = 10
#水电费/月
water = 10
electricity = 30

#月租
price = rent_oneday * 30 + water + electricity
print(price)

#buy apple
#apple_price_str = input("请输入价格: ")
#apple_weight_str = input("请输入重量: ")

apple_price = float(input("请输入价格: "))
apple_weight = float(input("请输入重量: "))

money = apple_price * apple_weight
print(money)

#抹余
intmoney = int(money)
print(intmoney)

格式化字符

  • %s 字符串
  • %d 整数 %06d表示输出的整数显示位数，不足的地方用0补全
  • %f 浮点数 %.02f代表小数点后只显示两位
  • %% 输出%
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
name = "Alice"
print("你好，我是%s，请多多关照" % name)

account = 10086
print("Your number is %d" % account)
print("Your number is %05d" % account)

price = 5.00
weight = 8.00
money = price * weight
print("一共 %.02f 元" % money)
print("单价 %f 元/斤，买了 %f 斤，支付 %f 元" % {price, weight, money})

scale = 6.25
print("比例是 %.02f%%" % (scale * 10))

比较运算符

运算符 描述 示例 结果
== 等于 5 == 3 False
!= 不等于 5 != 3 True
> 大于 5 > 3 True
< 小于 5 < 3 False
>= 大于等于 5 >= 3 True
<= 小于等于 5 <= 3 False

if语句

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
age = 17
if age >= 18 :      #if语句带缩进的代码都属于一个代码块
    print("You are man")
else :
    print("good bye kid")

#买菜
price = float(input("请输入金额"))
weight = float(input("请输入重量"))
money = price * weight
print("一共%.2f" % money)

if money >= 500 :
    print("给你张优惠卷")
else :
    print("欢迎下次光临")

#逻辑运算and or not

# and
age = 18  #✔️
weights = 130  #✔️
if age >= 18 and weight >=120 :  
    print("合格")   #✔️
else: 
    print("不合格")

# or
age = 16
height = 180  #✔️
if age >= 18 or height >= 170 :
    print("合格")  #✔️
else : 
    print("不合格")

# not
human = True
if not human:
    print("离开地球")
else ：
    print("你好人类")  #✔️


# elif
myName = "Steve"
if myName == "Alice":
    print("Hello Alice")

elif myName == "Steve":  #✔️
    print("Hello Steve")

else :
    print("Who are you")

# if嵌套 --洗浴
bath_tickets = True
check_tattoo = 3
limit_tattoo = 5
if bath_tickets:   #✔️
    print("检查下纹身")
    if check_tattoo <= 5:   #✔️
        print("欢迎来洗浴")
    else: 
        print("您的纹身超过 %d 厘米" % limit_tattoo)
else：
    print("抱歉，请买票")

石头剪刀布 rendom模块

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
user = int(input("请输入你要出的内容: 石头1 剪刀2 布3: "))
computer = 1

if ((user == 1 and computer == 2) 
        or (user == 2 and computer == 3) 
        or (user == 3 and computer == 1)):

    print("You win")

elif user == computer: 
    print("pingju")

else: 
    print("You lose")


#random 
import random
user = int(input("出拳 石头1 剪刀2 布3: "))
computer = random.randint(1, 3)
print(computer)
3
if ((user == 1 and computer == 2) 
        or (user == 2 and computer == 3) 
        or (user == 3 and computer == 1)):

    print("You win")

elif user == computer: 
    print("pingju")

else: 
    print("You lose")

赋值运算符

运算符 描述 示例
= 简单赋值运算符 c = a + b
+= 加法赋值运算符 c += a → c = c + a
-= 减法赋值运算符 c -= a → c = c - a
*= 乘法赋值运算符 c *= a → c = c * a
/= 除法赋值运算符 c /= a → c = c / a
//= 整除赋值运算符 c //= a → c = c // a
%= 取模赋值运算符 c %= a → c = c % a
**= 幂赋值运算符 c **= a → c = c ** a

while 循环

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
sayhi = "Hello world"
i = 0
while i <= 10 :
    
    print(sayhi) 
    i = i + 1
print("i = %d" % i)

#0-100
i = 0
sum = 0
while i <= 100 :
    sum += i
    i += 1
print("sum = %d, i = %d" % (sum, i))

#偶数求和
i = 0
sum = 0
while i <= 100 :
    i += 1
    if i % 2 == 0 : # 奇数 != 0
        sum += i
print("i = %d" % i)

print("sum = %d" % sum)

#break
i = 0
while i < 10 :
    if i >= 5 :
        break
    i += 1
print("i = %d" % i)

# continue
i = 0
while i < 10:
    if i == 4:
        i += 1
        continue
    print(i)
    i += 1
print("i = %d" % i)

# 循环嵌套 外层while：吃几顿饭  内层while：一顿饭吃几口
i = 1
while i < 10:
    print("*" * i, end="") #end=“” 不换行
    i += 1

i = 1
while i <= 10:
    col = 1
    while col <= i:
        print("*", end="")
        col += 1
    i += 1
    print("")#用于换行


# 99乘法表
row = 1
while row <= 9:
    col = 1
    while col <= row:
        print("%d * %d = %d" % (col, row, col * row), end=" ")
        col += 1
    print("")
    row += 1

转义字符

转义字符 名称 说明 示例
\n 换行 将光标移动到下一行 print("Hello\nWorld")
\t 制表符 插入一个水平制表位（Tab） print("A\tB")
\\ 反斜杠 表示一个反斜杠字符 print("\\")
\' 单引号 在单引号字符串中表示单引号 print('I\'m OK')
\" 双引号 在双引号字符串中表示双引号 print("He said \"Hi\"")
\r 回车 光标移到行首（覆盖前面内容） print("Hello\rHi")
\b 退格 删除前一个字符 print("AB\bC")
\f 换页符 很少使用，部分环境有效 print("Hello\fWorld")
\v 垂直制表符 很少使用 print("A\vB")
\0 空字符 表示字符串结尾（C风格） print("\0") 
1
2
3
4
5
6
7
8
row = 1
while row <= 9:
    col = 1
    while col <= row:
        print("%d * %d = %d" % (col, row, col * row), end="\t")
        col += 1
    print("")
    row += 1

函数

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
def int_test(): #可以在另一个文件import
    """函数的文档注释"""
    row = 1
    while row <= 9:
        col = 1
        while col <= row:
            print("%d * %d = %d" % (col, row, col * row), end="\t")
            col += 1
        print("")
        row += 1 #封装
int_test()  #调用

def sayhi():
    print("Hello")
    print("Hello")


#函数的参数
def sum_2_num(a, b):  #形参
    sum = a + b
    print(sum)
sum_2_num(20, 30)  #实参

#return

def sum_2_num(a, b):
    sum = a + b
    return sum
sum_test = sum_2_num(20, 30)
print("结果: %d" % sum_test)


#嵌套
def sum_test1(a, b):
    sum = a + b
    print(sum)
sum_test1(2, 3)
def sum_test2(c, d):
    sum2 = c + d
    sum_test1(c, d)
sum_test2(2, 5)

###
def test(char, times):
    print(char * times)
test("-", 666)


def test(char, times):
    i = 0
    while i <= 5:
        print(char * times)
        i += 1


def test(char, times):
    i = 0
    while i < 5:
        print(char * times)
        i += 1
test("-", 10)


def test(char, times):
    """
    test 的 Docstring
    
    :param char: 說明
    :param times: 說明
    """
    i = 0
    while i <= 4:
        print(char * times)
        i += 1
test()

模块

  • 每一个py结尾的文件都是一个模块
  • 在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具
  • pyc文件 会把导入的模块编译成字节码作为启动速度优化

…

列表

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
arr = ['Alice', 'Bob', 'Steve']
test = ['Hello', 'Hi']

#取值 取索引
print(arr[0])  #Alice

#索引数据位置
print(arr.index("Bob"))  #1

#修改数据
arr[2] = "Steven"  
print(arr)  # ['Alice', 'Bob', 'Steven']


# 增加数据
arr.append("Ray") # 末尾追加
print(arr)  # ['Alice', 'Bob', 'Steven', 'Ray']


arr.insert(1, "Kai") #指定索引位置插入数据
print(arr)  # ['Alice', 'Kai', 'Bob', 'Steven', 'Ray']


arr.extend(test) #把其它列表内容追加在当前列表末尾
print(arr)  # ['Alice', 'Kai', 'Bob', 'Steven', 'Ray', 'Hello', 'Hi']


# 删除数据
arr.pop() # 默认删除末尾数据，支持索引删除指定数据

arr.remove("Alice")  #删除指定数据 有重复数据删除第一个
print(arr)  #['Kai', 'Bob', 'Steven', 'Ray', 'Hello']

arr.clear()  #清理所有数据 
print(arr)  # []

new_arr = [1, 2, 3]
del new_arr[1]   #del 讲变量从内存中删除
print(new_arr)  # [1, 3]

# len count
i = 0
while i < len(arr):  # len 统计列表长度 n+1
     print(i)
     i += 1
print("i = %d" % i)

print(arr.count(5)) # 统计指定数据出现次数


#排序

arr = [1, 2, 3, 4, 2]

arr.sort() #正序 abcd 1234
print(arr)

arr.sort(reverse=True) #倒序 dcba 4321
print(arr)

arr.reverse()  #逆序 [1, 2, 2, 3, 4]
print(arr)


#循环遍历

arr = ['Alice', 'Ray']
for myName in arr:
    print("my name is: %s" % myName)

元组

  • Tuple 元组的元素不能修改
    • 元组表示多个元素组成的序列
  • 用于存储一串信息，数据之间用,分割
  • 元组用()定义
  • 元组的索引从0开始
  • 通常存储不同类型的数据
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
info_tuple = ("Steve", 1, 2, "Steve")

#取值 取索引
info_tuple(0)  # Steve
info_tuple.index("Steve")  #0
# 计数 长度
info_tuple.count("Steve")  #2
len(info_tuple)  #4


#单元素元组
a_tuple = (5,)
type(a_tuple)  #tuple

#循环遍历
for i in a_tuple:
    print(i)


#格式化字符串
info_tuple = ("Alice", 20, 1.85)
info_str = "My name is %s age %d height %.02f" % info_tuple
print(info_str)  # My name is Alice age 20 height 1.85



#元组和列表转换

#元组转列表
list(元组)

#列表转元组
tuple(列表)

字典

  • dictionary 是python除列表外最灵活的数据类型
  • 使用键值对存储数据
    • 键key是索引
    • 值value是数据
    • 键和值直接使用:分割
    • 键必须是唯一的
    • 值可以取任何数据类型，键只能使用字符串、数字、元组
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
test = {"name": "Steve",
        "age": 18,
        "height": 1.85}

#取值
print(test["name"])  #Steve

# 修改/增加
test["age"] = 17

#删除
test.pop("height")

#统计键值对数量
len(test)  #2

#合并字典 如果合并字典中包含已经存在的键值对 则会覆盖原有键值对
test1 = {"key": 22}
test.update(test1)

#清空
test.clear()

#循环遍历

for i in test:
    print("%s - %s" % (i, test[i]))

# 字典与列表组合
test = [{"name": "Steve",
        "age": 18,
        "height": 1.85},
        {"name"： "Alice",
        "age" : 17,
        "height": 1.77}]
for i in test:
    print(i)

字符串

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
s = "Hello world"
print(s[0])  #H

#字符串长度
print(len(s))

print(count("l"))

print(s.count("l"))  #3

s = "Hello world"
print(s[0])

a = " "
print(a.isspace())


arr = "123456789"

print(arr[1: 5]) # 12

print(arr[0: ])  #123456789

print(arr[0: 6])  #123456

print(arr[:6])  #123456

print(arr[:])  #123456789

print(arr[::2])  #13579

print(arr[1::2])  #2468

print(arr[-1])  #9

print(arr[2::-1])  #321

print(arr[-2:])  #89

print(arr[0::-1])  #1

print(arr[-1::-1])  #987654321

公共方法

内置函数

  • len 计算容器中元素个数
  • del 删除变量 del有两种方式
  • max 返回容器中元素最大值 如果是字典，只针对Key比较
  • min 返回容器中元素最小值 如果是字典，只针对Key比较

切片

- 字典不支持切片

运算符

- 字典不支持 + * 以及比较运算符

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

"a" in "abcde"  #true

"a" not in "abcde"  #false


#for else

for num in [1, 2, 3, 4]:
    print(num)
    if num == 2:
        break
else:
    print("done")
print("OK")


dit = [{"name": "Alice"},
       {"name": "Steve"}]
find_name = "Ray"

for i in dit:
    print(i)
    if i["name"] == find_name:
        print("i find %s" % find_name)
        break
else:
    print("i can't find %s" % find_name)
print("循环结束")

名片管理

…

PS: 成绩管理系统练习
PPS: 商品库存管理练习

变量的引用

  • 使用id()函数可以查看变量中保存数据所在的内存地址
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a = 1
print(id(a))  #140725866916280
b = a
print(id(b))  #140725866916280
a = 2
print(id(a))  #140725866916312



def test(num):
    print("函数内部%d对应的内存地址是%d" % (num, id(num)))

a = 10
print("a变量保存数据的内存地址是 %d" % id(a))

test(a)

可变和不可变类型

  • 不可变类型

    • 数字类型 int, bool, float, complex, long(2.x)
    • 字符串 str
    • 元组 tuple

  • 可变类型

    • 使用方法修改数据不会影响列表和字典在内存中的地址. 一旦使用赋值语句 内存地址就会变化.
    • 列表 list
    • 字典 dict
      • 字典的key只能使用不可变类型

哈希（hash）

  • 哈希是一种算法
  • python中hash(0)只接收不可变类型
  • Python 的 hash 是把一个对象转换成固定长度的整数值，用于快速比较和查找（主要给 dict、set 用）

局部变量和全局变量

  • 局部变量是在函数内部定义的变量，只能在函数内部使用
  • 局部变量 不同的函数可以定义相同名字的局部变量 彼此之间不会产生影响
  • 全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量
  • 全局变量 函数内部不能直接修改全局变量,如果使用赋值语句会在函数内部定义一个局部变量
  • 如果在函数中需要修改全局变量可以使用global关键字 => global var
  • 开发时应该把全局变量放在所有函数上方 这样能保证函数都可以访问全局变量
  • 全局变量命名建议添加g_ 或 gl_ 前缀

局部变量的生命周期

  • 所谓生命周期就是变量从被创建到被系统回收的过程
  • 局部变量在生命周期内，可以用来存储函数内部临时用到的数据
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

# 局部变量
a_list = []
def test():
    # 出生： 执行了下方代码之后 才会被创建
    # 死亡： 函数执行完成之后
    a = [1, 2, 4]
    print(a)
    a.append(6)

def test2():
    b = [1, 3, 5]
    print(b)  # [1, 3, 5]
    a_list.append(2)
    a.append(2) # NameError name"a" is not defined
    print(a_list)  # [2]
test2()


num = 10
def test():
    print(num)
    print(title)
    print(c)  #报错

title = "Hello"
test()
c = 9

函数参数和返回值的作用

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
# 利用元组返回多个值
def measure():
    print("测量开始...")
    temp = 40
    wetness = 50
    print("测量结束...")

    #return (temp, wetness) 如果函数返回类型是元组 可以不加括号
    return temp, wetness

result = measure()
print(result)

# 单独处理
#麻烦
print(result[0]) # 温度
print(result[1]) # 湿度

#简单
gl_temp, gl_wetness = measure()
print(gl_temp)
print(gl_wetness)

#交换数字 a = 6  b = 100
a = 6
b = 100
#解法1
c = b
b = a
a = c
#解法2

a = a + b
b = a - b
a = a - b

#解法3

a, b = b, 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
36
37
38
39
40
41
42
43
44
45
46
# 在函数内部，针对参数使用赋值语句 不会修改到外部实参变量
def demo(num, num_list):
    print("内部")

    num = 100
    num_list = [1, 2, 3]
    print(num, num_list)
    print("done")

gl_num = 99
gl_list = [4, 5, 6]
demo(gl_num, gl_list)
print(gl_num)
print(gl_list)


# 如果传递的参数是可变类型，在函数内部使用方法修改了数据的内容，同样会影响外部的数据
def demo(num_list):
    print("内部")

    num_list.append(9)

    print(num_list)  # [1, 3, 4, 9]

gl_list = [1, 3, 4]
demo(gl_list)
print(gl_list)  #  [1, 3, 4, 9]



def demo(num, num_list):
    print("start")

    num += num  # 18

    #列表变量+=本质属于extend方法
    num_list += num_list  # [1, 3, 4, 1, 3, 4]
    print(num)

gl_num = 9
gl_list = [1, 3, 4]
demo(gl_num, gl_list)

print(gl_num) # 9

print(gl_list)  # [1, 3, 4, 1, 3, 4]

缺省参数

  • 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数
  • 指定缺省参数的默认值时应该使用最常见的值作为默认值
  • 如果一个参数的值不能确定 则不应该设置默认值
  • 带有默认值的缺省参数必须在参数列表末尾
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
gl_list = [1, 3, 4, 2]

gl_list.sort(reverse=True)
print(gl_list)


def print_info(name, gender = True):

    """
    print_info 的 Docstring
    
    :param name: 姓名
    :param gender: 性别
    """

    gender_text = "man"
    if not gender: 
        gender_text = "girl"
    print("%s 是 %s" % (name, gender_text))

print_info("小明")
print_info("Alice", 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
def demo(num, *nums, **person):
    print(num)
    print(nums)
    print(person)


demo(1)

demo(1, 2, 3, 4, 5)

demo(1, 2, 3, 4, 5,name= "Alice")


#求任意多个数字的和

def sum_number(*nums):
    a = 0
    print(nums)
    for n in nums:
        a += n
    return a

result = sum_number(1, 2, 3)
print(result)



#拆包
def demo(*args, **kwargs):
    print(args)
    print(kwargs)


gl_nums = (1, 2, 4)
gl_dict = {"name": "Alice", "age": 18}


demo(gl_nums, gl_dict)

"""
((1, 2, 4), {'name': 'Alice', 'age': 18})
{}
"""

demo(*gl_nums, **gl_dict) 
"""
(1, 2, 4)
{'name': 'Alice', 'age': 18}
"""

递归

  • 一个函数内部调用自己
  • 函数内部代码相同，只针对参数不同 处理的结果不同
  • 当参数满足一个条件 函数不再执行 这称为递归的出口 如果没有出口会出现死循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def sum_numbers(num):
    print(num)
    if num == 1:
        return
    sum_numbers(num - 1)

sum_numbers(3)# 3 2 1


def sum_numbers(num):
    #出口
    if num == 1:
        return 1
    temp = sum_numbers(num - 1)
    #数字相加
    return num + temp

result = sum_numbers(3)
print(result) #1+2+3 = 6

面向对象

  • Object Oriented Programming – OOP
  • 面向过程和面向对象是两种不同的编程方式
  • 根据职责在一个对象中封装多个方法
  • 是专门应对复杂的开发项目，提供的固定套路
  • 面向对象开放前先进行需求分析

类(class)

  • 类 是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
  • 特征被称为属性， 行为被称为方法
  • 类是一个模板 是负责创建对象的
  • 类只有一个 对象可以有很多个

dir 内置函数

  • dir可以查看python提供的内置方法/属性
1
2
3
def demo():
    print("Hi")
print(dir(demo))
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
class Cat:
    def eat(self):
        print("cat like eat fish")
    
    def drink(self):
        print("cat like drink water")

tom = Cat()
tom.eat()
tom.drink()

print(tom)

addr = id(tom)
print("%x" % addr) # %d返回十进制内存地址，%x 返回十六进制内存地址


#初始化对象

class Cat:
    def eat(self):
        print("%s like eat fish" % self.name) #通过self访问对象的属性 也可以通过self调用其它对象的方法
    
    def drink(self):
        print("%s like drink water" % self.name)

tom = Cat()
tom.name = "Bad Cat"
tom.eat()
tom.drink()

lazy_tom = Cat()

# 增加属性
lazy_tom.name = "Good cat"  # 不推荐 找不到属性 程序会报错


lazy_tom.eat()
lazy_tom.drink()



#初始化方法
class Cat:

    def __init__(self, new_name):
        print("初始化方法")
        
        #self.属性名 = 属性初始值
        #self.name = "Bob"
        self.name = new_name

    def eat(self):
        print("%s eat fish" % self.name)
# 创建对象时自动调用初始化方法
tom = Cat("Aiice")
print(tom.name)

lazy_cat = Cat("Steve")
lazy_cat.eat()

#__del__方法

class Cat:
    def __init__(self, new_name):

        self.name = new_name
        print("%s 来了" % self.name)

    def __del__(self):
        print("%s 走了" % self.name)

tom = Cat("Alice")
del tom
print("=" * 30)



#__str__方法  & 多个对象之间互不干扰
class Person: 
    def __init__(self, name, weight):
        #self.属性 = 形参
        self.name = name
        self.weight = weight
        

    def __str__(self):
        return "my name is %s weight is %.02f" % (self.name, self.weight)

    def run(self):
        self.weight -= 0.5

    def eat(self):
        self.weight += 1

xiaoming = Person("小明", 75.0)
xiaomei = Person("小美", 45.0)

xiaoming.run()
xiaoming.eat()

xiaomei.run()
xiaomei.eat()
print(xiaoming)
print(xiaomei)


####
class Car:
    def __init__(self, plate_number, brand):
        self.plate_number = plate_number
        self.brand = brand

    def __str__(self):
        return f"{self.brand} - {self.plate_number}"

class ParkingLot:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cars = []

    def park(self, car):
        if len(self.cars) >= self.capacity:
            print("车位已满 无法停车")
            return
        
        self.cars.append(car)
        print(f"车辆{car} 停车成功")
        
    def leave(self, place_number):
        for car in self.cars:
            if car.plate_number == place_number:
                self.cars.remove(car)
                print(f"车辆{car} 已离开停车场")
                return
            
        print("找不到该车牌车辆")

    def show_status(self):
        print(f"\n停车场容量：{self.capacity}")
        print(f"当前车辆数：{len(self.cars)}")
        print(f"剩余车位：{self.capacity - len(self.cars)}")

        if not self.cars:
            print("（停车场为空）")
        else:
            print("当前停放车辆：")
            for car in self.cars:
                print(" -", car)



# 创建停车场
parking_lot = ParkingLot(2)

# 创建车辆
car1 = Car("粤A12345", "Tesla")
car2 = Car("京B88888", "BMW")
car3 = Car("沪C66666", "Audi")

# 停车
parking_lot.park(car1)
parking_lot.park(car2)
parking_lot.park(car3)   # 超出容量

# 查看状态
parking_lot.show_status()

# 离开
parking_lot.leave("京B88888")
parking_lot.leave("不存在的车牌")

# 再次查看
parking_lot.show_status()


封装对象

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
class Gun:
    def __init__(self, model):

        self.model = model
        self.bullet_count = 0

    def add_bullet(self, count):
        self.bullet_count += count

    def shoot(self):
        if self.bullet_count <= 0:
            print("[%s]没有子弹了" % self.model)
            return
        self.bullet_count -= 1
        print("[%s] 发射中...[%d]" % (self.model, self.bullet_count))


class Soldier:
    def __init__(self, name):
        self.name = name
        #新兵没枪
        self.gun = None
    def fire(self):
        #if self.gun == None:
        if self.gun is None:
            print("[%s] 还没枪" % self.name)
            return
        print("gogogo [%s]" % self.name)

        self.gun.add_bullet(50)
        self.gun.shoot()

ak47 = Gun("AK47")

xiaoming = Soldier("xiaoming")
xiaoming.gun = ak47
xiaoming.fire()
print(xiaoming)

身份运算符

  • 用于笔记两个对象的内存地址是否一致 是否是对同一个对象的引用
  • 针对None 建议使用is 判断
  • is是判断两个标识符是不是引用同一个对象，x is y, id(x) == id(y)
  • is not是判断两个表示是不是引用不同对象，x is not y, id(x) != id(y)
  • is是用于判断两个变量引用的对象是不是同一个，==是判断引用变量的值是不是相等

私有属性和私有方法

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
class Women:
    def __init__(self, name):
        self.name = name
        #私有属性
        self.__age = 19
        
        #私有方法
    def __secret(self):
        print("%s 的年龄是 %d" %(self.name, self.age))


xiaofang = Women("xiaofang")
#外界访问方法
class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 19

    def __secret(self):
        print("%s 的年龄是 %d" %(self.name, self.age))


xiaofang = Women("xiaofang")

#属性
print(xiaofang._Women__age)

#方法
xiaofang._Women__secret()

单继承

  • 继承可以实现代码的重用，相同的代码不需要重复编写
  • 概念：子类拥有父类的所有方法和属性
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
class Animal:
    def eat(self):
        print("eat")
    def drink(self):
        print("drink")
    def run(self):
        print("run")
    def sleep(self):
        print("sleep")

        # 继承父类
class Dog(Animal):
    def bark(self):
        print("wang wang wang")

#传递性  Animal => Dog => Flydog
class Flydog(Dog):
    def fly(self):
        print("im fly")

class Cat(Animal):
    def catch(self):
        print("Meo Meo")


steve = Flydog()

steve.fly()
steve.bark()
steve.eat()

steve.catch() #Error Flydog和Cat没有直接继承关系

方法重写

  • 如果父类的方法实现和子类的方法实现完全不同
  • 可以使用覆盖的方式，在子类中重新编写父类的方法实现 =>在子类中定义一个和父类同名的方法
  • 重写后只会调用子类重写的方法
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
class Animal:
    def eat(self):
        print("eat")
    def drink(self):
        print("drink")
    def run(self):
        print("run")
    def sleep(self):
        print("sleep")

class Dog(Animal):
    def bark(self):
        print("wang wang wang")

class Flydog(Dog):
    def fly(self):
        print("im fly")

    #
    def bark(self):
        print("Ahhh Ahhh")


steve = Flydog()

steve.fly()

#执行子类重写的方法
steve.bark()



###
class Animal:
    def eat(self):
        print("eat")
    def drink(self):
        print("drink")
    def run(self):
        print("run")
    def sleep(self):
        print("sleep")

class Dog(Animal):
    def bark(self):
        print("wang wang wang")

class Flydog(Dog):
    def fly(self):
        print("im fly")

    def bark(self):
        print("Ahh Ahh")
        #调用父类中封装的方法
        super().bark() #  wang wang wang

        # 父类.方法(self)
        Dog.bark(self) #  wang wang wang
        print("^$^$^$^$^&&&*")

steve = Flydog()

steve.fly()

#执行子类重写的方法
steve.bark()

父类的私有属性和方法

  • 子类对象不能在自己的方法内部直接访问父类的私有属性和私有方法
  • 可以通过父类公有方法简介访问私有属性和私有方法
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
class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 20

    def __test(self):
        print("私有方法 %d %d" % (self.num1, self.__num2))
    
class B(A):
    def demo(self):
        print("访问父类私有属性 %d" % self.__num2)
        self.__test()

b = B()
print(b)



###
class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 20

    def __test(self):
        print("私有方法 %d %d" % (self.num1, self.__num2))
    
    def test(self):
        print("公有方法 %d %d" % (self.__num2))
        self.__test()

    
class B(A):
    def demo(self):
        print("访问父类私有属性 %d" % self.__num2)
        #调用父类公有方法
        self.test()

b = B()
print(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
50
51
52
53
54
55
56
57
58
class A:
    def test(self):
        print("test")

class B:
    def demo(self):
        print("demo")

class C(A, B):
    pass


user = C()
user.demo()
user.test()



###
class A:
    def test(self):
        print("A--test")
    def demo(self):
        print("A--demo")


class B:
    def test(self):
        print("B--test")
    def demo(self):
        print("B--demo")

class C(A, B):
    pass


# __mro__可以查看方法搜索顺序
print(C.__mro__)

user = C()
user.demo()
user.test()


# 新式类 以object为基类的类 推荐用  #在python3中所有类都是新式类
class A(object):
    pass
a = A()

print(dir(a))

#经典类 不以obje为基类的类 不推荐

class B:
    pass

b = B()
print(dir(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
class Dog(object):
    def __init__(self, name):
        self.name = name
    
    def game(self):
        print("%s蹦蹦跳跳的玩耍" % self.name)

class Xiaoming(Dog):
    def game(self):
        print("%s玩耍" % self.name)

class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self,dog):
        print("%s和%s玩耍" % (self.name, dog.name))

        dog.game()

#Steve = Dog("Steve")
Steve = Xiaoming("fly")

xiaoxiaoming = Person("xiaoming")

xiaoxiaoming.game_with_dog(Steve)

类属性和实例属性

  • 类属性就是给类对象中定义的属性
  • 通常用来记录与这个类相关的特征
  • 类属性不会用于记录具体对象的特征
  • 访问类属性方法： 1.类名.类属性
  • 访问类属性方法： 2.对象.类属性 （不推荐）使用对象,类属性 = 值 的赋值语句 只会给对象添加一个属性，不会影响类属性的值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Tools(object):

    # 使用赋值语句定义类属性， 记录所有工具对象的数量
    count = 0

    def __init__(self, name):
        self.name = name

        #类属性值+1
        Tools.count += 1


tool1 = Tools("钳子")
tool1 = Tools("斧子")

# 输出创建对象的总数
print(Tools.count)

类方法和静态方法

  • 类属性就是针对类对象定义的属性
  • 类方法就是针对类对象定义的方法
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
#修饰器标识 告诉解释器 这是类方法
@classmethod
def Person(cls):
    pass



###
class Tool(object):
    count = 0

    @classmethod
    def show_tool_count(cls):
        print("tool count: %d" % cls.count)

    def __init__(self, name):
        
        self.name = name
        Tool.count += 1

tool1 = Tool("斧子")

Tool.show_tool_count()




###静态方法
class Dog(object):


    #使用修饰器定义静态方法
    @staticmethod
    def run():
        print("run ...")

Dog.run()

###综合
class Game(object):
    top_score = 0
    def __init__(self, player_name):
        self.player_name = player_name
    
    @staticmethod
    def show_help():
        print("a help website")

    @classmethod
    def show_top_score(cls):
        print("history: %d" % cls.top_score)

    def start_game(self):
        print("%s start game... " % self.player_name)

Game.show_help()
Game.show_top_score()
steve = Game("steve")
steve.start_game()

单例

  • 设计模式

  • 使用设计模式是为了可重用代码，让代码更容易被他人理解，保证代码可靠性

  • 单例设计模式

  • 让类创建的对象，在系统中只有唯一的一个实例

  • 每一次执行类名()返回的对象，内存地址是相同的

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
class MusicPlayer(object):

    def __new__(cls, *ages, **kwargs):

        print("创建对象 分配空间")
        instance = super().__new__(cls)
        return instance
    
    def __init__(self):
        print("播放器初始化")

player = MusicPlayer()

print(player)





class MusicPlayer(object):
    instance = None
    init_flag = False
    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance

    def __init__(self):
        if MusicPlayer.init_flag:
            return
        print("初始化播放器")
        MusicPlayer.init_flag = True


player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)

异常

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
try:
    num = int(input("请输入整数："))  #尝试执行的代码
except:
    print("输入整数 谢谢")  #出现的错误处理


#根据错误类型捕捉错误
try:
    num = int(input("请输入整数："))  #尝试执行的代码
    nums = 8 / num
    print(nums)
except ValueError:
    print("输入整数 谢谢")  #出现的错误处理
except ZeroDivisionError:
    print("不要输入0")

#捕获未知错误
except Exception as result:
    print("未知错误 %s" % result)

else:  #没有异常才会执行
    print("无异常")
finally:  #有没有异常都执行
    print("...")
#完整异常捕获语句☝️



def demo():
    return int(input("输入整数："))

def demo1():
    return demo()

try: #利用异常的传递性，在主程序捕获异常
    demo()
    demo1()
except Exception as result:
    print("错误： %s" % result)


##
def input_password():
    userpassword = input("输入密码：")
    
    if len(userpassword) >= 8:
        return userpassword
    
    print("主动抛出异常")

    # 创建异常对象
    ex = Exception("密码长度不够")
    # 主动抛出异常
    raise ex
try:
    print(input_password())
except Exception as result:
    print(result)

模块

  • 如果模块名字太长可以用as给模块起别名
  • 如果在不同的模块中导入同名的工具 会执行下面的 后导入模块的函数会覆盖先导入的
  • 可以使用as关键字避免重名问题
  • import文件时 文件中没有任何缩进的代码 都会被执行一遍
  • 测试模块时 可以用-__name__
1
2
if __name__ == "__main__":
    print(__name__)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import test as model

#from import 局部导入
from test import addlist
addlist()

#导入所有工具 --不推荐
from test import *


#导入模块时会先搜索当前目录文件 有就导入 没有再去python系统目录搜索
# __file__可以查看模块完整路径
import random
rd = random.randint(0, 10)
print(rd)

包 package

  • 是一个包含多个模块的特殊目录
  • 目录下有一个特殊文件__init__.py
1
from . import xxx

发布模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#distutils.core模块已弃用
from setuptools import setup

setup(name="package name",
      version="1.0",
      description="描述信息",
      long_description="完整描述",
      author="作者",
      author_email="作者邮箱",
      url="网站",
      py_modules=["模块名称"...])

#构建模块
python3 setup.py build
#生成发布压缩包
python3 setup.py sdist

文件的基本操作

Python操作文件的方法

  • open 打开文件 并返回文件操作对象–默认以只读方式打开文件
  • read 将文件内容读取到内存
  • writw 将指定内容写入文件
  • close 关闭文件
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
file = open("README")

text = file.read()
print(len(text)) # 12

print("=" * 40)
# 读取文件后文件指针会发生变化
text = file.read()
print(len(text)) # 0
file.close()



file = open("README", "w")

text = file.write("helo")
print(text)


file.close()



#readline 方法

file = open("README")

while True:
    text = file.readline()
    if not text:
        break
    print(text)

file.close()



#小文件复制
file_read = open("README")
file_write = open("README复件", "w")
text = file_read.read()
file_write.write(text)

file_read.close()
file_write.close()


#大文件复制
file_read = open("README")
file_write = open("README复件", "w")

while True:
    text = file_read.readline()
    if not text:
        break
    file_write.write(text)



file_read.close()
file_write.close()

执行文件和目录管理操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import os
os.rename("文件名称", "要修改的名称") #重命名

os.remove("文件名称")    # 删除文件

os.listdir("目录名称") #目录列表

os.mkdir("目录名称") #创建目录

os.rmdir("目录名称") #删除目录

os.getcwd() #获取当前目录

os.chdir("目录名称")  # 修改工作目录

os.path.isdir("文件路径") #判断是否是文件

eval 函数

1
2
3
4
5
6
#不要使用eval直接input结果
print(eval("1 + 1"))

input_str = input("请输入算术题：")

print(eval(input_str))

…

IP

1
2
3
4
5
6
7
8
9
from random import randint

def random_ip():
    ip = '.'.join([str(randint(1, 255))for i in range(4)])
    return ip

if __name__ == "__main__":
    for i in range(10):
        print(random_ip())