python基础入门视频-Python基础入门视频课程——笔记

Python基础，主讲：汤小洋

一、Python简介

1. Python是什么？

​ Python是一种面向对象的解释型计算机程序设计语言，由荷兰人Guido van Rossum（龟叔）于1989年发明，第一个公开发行版发行于1991年。

​ 诞生：1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，即Python（TIOBE编程语言排行榜）

​ 作用：开发网站、后台服务、工具脚本、爬虫、数据分析、人工智能等

​ 特点：

优点：简单（定位：简单、优雅、明确）、代码量少（人生苦短 我用python）、功能强大（大量的第三方库）

缺点：运行速度慢、代码不能加密

补充：Python是一门解释型语言，不需要编译，类似于PHP，不同于Java、C#等编译型语言

2. 安装Python

​ Python是跨平台的，执行Python代码需要解释器

​ 版本：2.x、 3.x

​ 安装步骤：

Windows

Linux

mkdir python # 创建Python的安装目录

tar zxf Python-3.6.5.tgz # 解压缩

cd Pyton-3.6.5

./configure --prefix=/home/soft01/python # 配置，指定安装位置

make # 编译

make install # 安装

cd /home/soft01/python/bin

./python3

# 将python路径添加到PATH变量中

vi ~/.bashrc

export PATH=/home/soft01/python/bin:$PATH

source ~/.bashrc

​

二、第一个Python程序

1. 使用Python交互模式

​ 执行python命令，就进入Python交互模式，提示符>>>，输入exit()退出交互模式

>>> 3+8

11

>>> print("Hello World")

Hello World

>>> name="tom"

>>> print(name)

tom

>>>exit()

2. 使用文本编辑器

​ 建议使用sublime或notepad++等，不要使用windows自带的记事本（会自动在文件的开头添加特殊字符）

​ 步骤：

创建Python脚本文件，以.py结尾

# -*- coding: utf-8 -*-

# 这是注释，第一个Python程序

print("Hello World")

name="唐伯虎"

print(name)

注：如果脚本中有中文，可能会报错，需要在文件的第一行添加一个特殊的注释

运行脚本

python hello.py

直接执行脚本

在Linux和Mac中可以直接执行.py脚本文件，方法：

在文件的第一行添加一个特殊的注释：#!/usr/bin/env python3

为文件添加执行权限：chmod a+x hello.py

直接执行脚本文件：./hello.py

3. 使用IDE工具

​ PyCharm，JetBrain公司出口

​ 使用步骤：

创建包

包中必须存在一个__init__.py文件，用于标识这是一个包

创建Python脚本

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

__author__ = "汤小洋"

# 输出，使用print()

print("hello world")

name = "alice"

print(name)

4. 基本使用

​ 输入和输出

使用print()

使用input()

​ 注释：

单行注释，以#开头

多行注释，使用三对单引号或三对双引号

​ 编码规范：

不要在行尾加分号

大小写敏感

适应添加空格、空行，使代码布局更优雅、美观、合理

使用缩进来表示代码块

三、Python基础

1. 变量和数据类型

​ 变量：

定义变量时不需要指定变量的类型，直接为变量赋值即可

变量名要符合命名规范

​ 数据类型：整型、浮点型、字符串、布尔、空值等

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

__author__ = "汤小洋"

"""

数据类型：整型、浮点型、字符串、布尔、空值等

"""

# 整型int

a = 3454566666666666666

print(a)

print(type(a))

# 浮点型float

b = 12.5

print(b, type(b))

# 字符串str，定义字符串可以使用单引号或双引号（推荐用单引号）

c = "ccc"

d = "ddd"

print(c, type(c))

print("张三说："今晚吃鸡吗？"")

# 字符串有多行时可以使用三对单引号，表示多行内容

e = """

welcome

to

itany

"""

print(e)

print(type(e))

# 布尔bool，取值：True、False

f = True

print(f, type(f))

g = 5 < 3

print(g)

print(5 + False) # True表示1，False表示0

# 空值 NoneType

h = None

print(h, type(h))

2. 字符串

​ 类型转换

# 将字符串转换数值

a = "25"

b = int(a)

print(type(a), type(b))

c = "12.5"

d = float(c)

print(type(c), type(d))

# 将数值转换为字符串

print("hello " + str(25)) # 数值类型不能直接和字符中进行拼接，需要进行类型转换

​ 字符串常用方法

string = " hello world "

print(string.islower())

print(string.isupper())

print(string.capitalize())

print(string.index("llo"))

print(string)

print(string.strip()) # 类似于java中的trim

print(len(string)) # 调用len()函数获取长度

​ 切片

name = "tom cruise"

print(name[0])

print(name[4], name[len(name) - 1], name[-1])

print(name[1:5]) # 获取索引为[1,5)的字符

print(name[:5]) # 表示从头获取

print(name[2:]) # 表示获取到末尾

print(name[1:8:2]) # 索引为[1,8)的字符，每两个取一个

print(name[::2]) # 所有字符，每两个取一个

​ 格式化

# 格式化字符串，在字符串中指定占位符

# 方式1：使用%运算符，%s表示任意字符，%d表示整数，%f表示浮点数

name = "tomaaaa"

age = 20

height = 180.5

print("大家好，我叫" + name + "，年龄：" + str(age) + "，身高：" + str(height))

print("大家好，我叫%2.4s，年龄：%d，身高：%.2f" % (name, age, height)) # 2.4s表示字符串长度为2-4位，.2f表示保留两位小数

print("当前时间：%d年-%02d月-%d日" % (2018, 5, 14)) # 指定月份为两位，不足两位则补0

# 方式2：使用format()方法，使用{}表示占位符

print("大家好，我叫{0}，年龄：{1}，身高：{2:.2f}".format(name, age, height))

print("大家好，我叫{name}，年龄：{age}，身高：{height}".format(age=age, name=name, height=height))

# 方式3：在字符串前面添加一个f，使用{变量名}来嵌入变量

print(f"大家好，我叫{name}，年龄：{age}，身高：{height}")

3. 运算符

​ 算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、条件运算符、成员运算符、身份运算符

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

__author__ = "汤小洋"

"""

Python中支持的运算符：

1.算术运算符

+ - * / % // **

不支持自增++和自减--

2.比较运算符

> < >= <= == !=或<>

3.赋值运算符

= += -= *= /+ %= **=

4.逻辑运算符

and or not

5.条件运算符，也称三目运算符

语法：条件为真时的结果 if 条件 else 条件为假时的结果

6.位运算符

与& 或| 非~ 异或^ 左移<< 右移>>

7.成员运算符

in

not in

8.身份运算符

is

is not

"""

# 1.算术运算符

print(3 + 5)

print(3 * 5)

print(30 * "-") # 乘法可以用于字符串

print(5 % 3)

print(5 / 3) # 除法，有小数

print(5 // 3) # 除法，取整

print(2 ** 3) # 幂

print(pow(2, 3))

i = 5

i = i + 1

print(i)

print("*" * 80)

# 2.比较运算符

j = 5

print(j > 2)

print(10 > j > 1) # 支持此写法

print("abc" > "acd") # 可以用于字符串的比较，比较的是字符串的Unicode编码

# 3.赋值运算符

a = 10

a += 5 # 等价于a= a+5

print(a)

# 4.逻辑运算符

print(True and False)

print(5 > 2 or 4 < 1)

print(not 5 > 2)

x = 0 # 0 表示False，非0表示True

y = 8

print(x and y) # 如果ｘ为True，则返回y；否则返回x

print(x or y) # 如果x为True，则返回x；否则返回y

print(not x) # 如果x为True，则返回False，否则返回True

# 5.条件运算符，也称三目运算符

print("aaa" if 5 < 2 else "bbb")

# 6.位运算符

a = 5 # 00000101

b = 8 # 00001000

print(a & b) # 两位都是1才为1，否则为0

print(a | b) # 只要有一位为1，则为1，否则为0

print(~a) # 如果为1，则为0，如果为0，则为1

print(a ^ b) # 如果两位相同，则为0，不同为1

print(b >> 2) # 二进制的所有位都向右移2位

# 7.成员运算符

c = [3, 5, 12, 15, 7, 2]

d = 5

print(d not in c)

# 8.身份运算符

m = [1, 3, 5, 7]

n = [1, 3, 5, 7]

x = n

print(m is n)

print(x is n)

"""

is 和 == 的区别

is 判断两个变量是否引用同一个对象

== 判断两个变量的值是否相等

"""

print(m == n)

4. 列表和元组

​ 列表list是一种有序的集合，用来存储多个值，可以向列表中添加或删除元素

​ 元组tuple与list很类似，也是用来存储多个值，但tuple中的元素只能在定义时初始化，初始化后就无法再修改

​ 总结：列表list和元组tuple都是Python内置的一种集合，一个可变的，一个是不可变的

# ---列表list

# 定义列表，使用[]

names = ["tom", "jack", "alice", "mike"]

print(names)

print(type(names))

# 获取/设置元素

print(names[1], names[:3])

names[0] = "lucy"

print(names)

# 追加元素

names.append("zhangsan")

# 在指定位置插入元素

names.insert(1, "lisi")

# 删除元素

names.remove("jack")

# 弹出元素

print(names.pop(0))

# 获取元素个数

print(len(names))

# 可以存储不同类型的数据

names.append(25) # 不建议

names.append(True)

print(names)

print("-" * 80)

# ------元组tuple

# 定义元组，使用()

nums = (3, 8, 13, 25, 38, 250)

print(nums)

print(type(nums))

print(nums[2], nums[-1])

print(nums[1:3])

# 解构赋值

# a = nums[0]

# b = nums[1]

# c = nums[2]

# d = nums[3]

# e = nums[4]

# f = nums[5]

a, b, c, d, e, f = nums

print(a, b, c, d, e, f)

5. 条件判断

​ 根据条件进行判断，从而执行不同的操作

​ 使用if...elif...else语句

6. 循环

​ 重复性的执行某个操作，称为循环

​ 两种：

while循环

for...in循环

# ----while循环

# 计算1到100的和

i = 1

sum = 0

while i <= 100:

sum += i

i += 1

print(sum)

# ----for...in循环

names = ["tom", "jack", "alice", "mike"]

for name in names:

print(name, end=",")

print()

# 使用range()函数生成一个序列

for i in range(1, 100, 2): # 生成一个[1,100)的整数序列，步长为2

print(i, end=",")

print()

# 计算1到100的和

sum = 0

for i in range(1, 101):

sum += i

print(sum)

​ break和continue关键字

7. 字典和集合

​ dict全称dictionary，使用键-值（key-value）存储数据，在其他语言中一般称为map

​ set是无序的，不允许重复

# ----字典

# 定义dict，使用大括号{}，与js中的json很类似

scores = {"tom": 98, "jack": 100, "alice": 60}

print(scores)

print(type(scores))

# 获取

print(scores["jack"])

print(scores.get("alice"))

# 添加/设置

scores["lucy"] = 89

scores["tom"] = 100

# 弹出（删除）

print(scores.pop("tom"))

# 判断是否存在指定的key

print("alice" in scores)

print(scores)

# 遍历

print(scores.keys())

print(scores.values())

print(scores.items())

for k in scores.keys():

print(k, scores[k])

print("-" * 80)

for v in scores.values():

print(v)

print("-" * 80)

for k, v in scores.items():

print(k, v)

print("-" * 80)

# -----set集合

# 定义set，使用大括号{}

# s = {3, 12, 5, 7, 34, 12, 3}

nums = [4, 23, 1, 23, 4, 23]

s = set(nums) # 调用set()函数将list转换为set，去除重复值

print(s)

print(type(s))

# 添加

s.add(666)

s.add(1)

# 删除

s.remove(1)

print(s)

# 遍历

for i in s:

print(i)

四、函数

​ 函数是实现特定功能的代码段的封装，在需要时可以多次调用函数来实现该功能

1. 内置函数

​ Python内置了许多非常有用的函数，可以直接调用

2. 自定义函数

​ 语法：

def 函数名(形参1,形参2,...):

函数体

​ 注意：

函数名可以包含数字、字母、下划线，但不能以数字开头

如果函数有返回值，使用return关键字

定义函数后函数中的代码并不会执行，需要调用函数才会执行

# 定义函数，使用def

def calc(num1, num2): # 必选参数，也称为位置参数，不能省略

res = num1 + num2

return res

# print(calc(3, 5)) # 调用函数

# 参数类型检查

def my_abs(x):

# 可以为函数添加文档注释，也称为文档字符串doc string

"""

计算绝对值

:param x: 参数

:return: 返回x的绝对值

"""

# 对参数类型进行检查

if not isinstance(x, (int, float)):

raise TypeError("参数类型不正确，只能为数值类型") # 抛出异常

if x >= 0:

return x

else:

return -x

# print(my_abs("aaa"))

# print(help(my_abs))

# 默认参数，即有默认值的参数

def my_pow(x, y=2):

if y == 0:

return 1

res = x

for i in range(y - 1):

res *= x

return res

# print(my_pow(5))

# 可变参数，使用*号，表示参数个数是可变的

def my_sum(x, *y):

print(x)

print(y) # 接收到的实际上是一个tuple

# my_sum(3, 5, 8, 12, 4)

# 不建议下面的这种写法，建议将必选参数放在最前面

def my_sum2(*y, x):

print(y)

print(x)

# my_sum2(12, 4, 2, 7, x=9) # 必选参数在后面时需要指定参数名

# 对于可变参数，可以直接传入list或tuple，只需要在参数前添加一个*

nums = [12, 4, 2, 64, 23, 9]

# my_sum(4, nums[0], nums[1], nums[2], nums[3], nums[4], nums[5])

# my_sum(4, *nums)

# 关键字参数，使用**，也表示参数个数是可变的，但传递的是带名称的参数

def f1(x, **y):

print(x)

print(y) # 接收到的实际上一个dict

# f1(3, a=5, b=9, c=18)

# 对于关键字参数，可以直接传入一个dict，只需要在参数前添加**

user = {"id": 1001, "name": "tom", "age": 18}

# f1(4, id=user["id"], name=user["name"], age=user["age"])

# f1(4, **user)

# 命名关键字参数，限制关键字参数的名字，使用*分隔，*号后面的参数表示命名关键字参数

def f2(x, *, name, age):

print(x)

print(name)

print(age)

# f2(4, name="alice", age=20)

# 接收任意参数

def f3(*args, **kwargs):

print(args)

print(kwargs)

f3(1, 43, "aaa", name="alice", age=20)

# 空函数，表示以后再实现

def empty():

pass # 使用pass

# 函数的返回值，返回多个值

def f1():

name = "tom"

age = 20

sex = "male"

return name, age, sex

# print(f1()) # 返回值实际上是一个tuple

a, b, c = f1()

# print(a, b, c)

# 函数的返回值，返回一个函数，即将函数作为返回值

def f2(x):

print(111)

z = 6

def f3(y):

print(x * y + z) # 内部函数使用了外部函数的参数或局部变量，称为闭包

return f3

# fn = f2(3)

# fn(5)

# 递归函数：一个函数在内部调用自身，这个函数就是递归函数

# 计算x的y次方，如计算2的5次方

def calc(x, y):

# 常规方式

# if y == 0:

# return 1

# i = 1

# res = x

# while i < y:

# res *= x

# i += 1

# return res

# 递归方式

# 2*2*2*2*2=2*(2*2*2*2)=2*(2*(2*2*2))=

if y == 0:

return 1

else:

return x * calc(x, y - 1) # 不停的调用自己，递归太深可能会抛出栈溢出异常

print(calc(2, 99999999999999))

3. 变量作用域和命名空间

"""

变量作用域scope：指的是变量生效的区域

两种作用域：

1.全局作用域

函数以外的区域都是全局作用域

在全局作用域中定义的变量，都是全局变量

2.函数作用域，也称为局部作用域

函数内的区域，每调用一次函数就会创建一个新的函数作用域

在函数作用域中定义的变量，都是局部变量

变量的查找顺序：

先在当前作用域中查找，如果没有则向上一级作用域中查找，直到查找全局作用域，如果还是没有，则报错

"""

a = 5 # 全局变量

if True:

c = 5 # 全局变量，在Python中没有块级作用域

def fn():

b = 8 # 局部变量

print("函数内部：a=", a)

print("函数内部：b=", b)

print("函数内部：c=", c)

fn()

print("函数外部：a=", a)

# print("函数外部：b=", b)

print("函数外部：c=", c)

x = 1

def f1():

x = 2

def f2():

x = 3

print(x)

print("-" * 80)

# global关键字

def fn2():

# a = 10 # 在函数中为变量赋值时，默认都是为局部变量赋值

# 如果希望在函数中修改全局变量，要使用global关键字来声明变量

global a

a = 10

print("函数内部：a=", a)

fn2()

print("函数外部：a=", a)

print("*" * 80)

"""

命名空间namespace：指的是变量存储的位置，每一个变量都要存储在指定的命名空间中

每个作用域都有一个对应的命名空间

全局命名空间，用来存储全局变量；函数命名空间，用来存储函数中的变量

命名空间实际上就是一个字典dict，是一个专门用来存储变量的字典

"""

# locals() 获取当前作用域的命名空间

scope = locals() # 在全局作用域中调用locals()，获取的就是全局命名空间

print(scope)

print(type(scope))

# 通过scope操作命名空间中的变量（不建议）

print(scope["a"])

scope["c"] = 666

scope["z"] = "tom"

print(scope["c"])

print(scope["z"])

# print(z)

print("*" * 80)

def fn3():

a = 888

scope = locals() # 在函数中调用locals()，获取到的是函数命名空间

scope["b"] = 222

print(scope)

print(scope["b"])

# globals() 可以在任意位置获取全局命名空间

global_scope = globals()

print(global_scope)

print(global_scope["a"])

fn3()

4. 高级特性

​ 迭代和列表生成式

# 导入模块

import collections

"""

迭代：也称为遍历，循环获取每一个元素

"""

for i in ["tom", "jack", "alice"]:

print(i, end=" ")

print()

for i in ("tom", "jack", "alice"):

print(i, end=" ")

print()

for i in {"name": "tom", "age": 18, "sex": "male"}.keys():

print(i, end=" ")

print()

for k, v in {"name": "tom", "age": 18, "sex": "male"}.items():

print(k, v)

for i in "hello":

print(i)

# 判断对象是否是可迭代的

print(isinstance("hello", collections.Iterable))

# 获取索引和值

# 方式1：自己获取索引

names = ["tom", "jack", "alice"]

for i in range(len(names)):

print(i, names[i])

# 方式2：使用enumerate()函数，转换为索引-元素对

print(enumerate(names))

print(isinstance(enumerate(names), collections.Iterable))

for k, v in enumerate(names):

print(k, v)

print("-" * 80)

"""

列表生成式：用来创建list的生成式

"""

# 生成[0,99]的list

# nums = range(0, 100)

nums = list(range(0, 100)) # 转换为list

# print(nums, type(nums))

# print(isinstance(range(0, 100), collections.Iterable))

# for i in range(0, 100):

# print(i)

# 生成一个包含[1,100]之间所有3的倍数的list

# 方式1

# lst = []

# for i in range(1, 101):

# if i % 3 == 0:

# lst.append(i)

# 方式2

lst = [i for i in range(1, 101) if i % 3 == 0] # 等价于a = list(range(1, 101))

print(lst)

​ 迭代器和生成器

"""

迭代器iterator：用来访问集合元素的一种方式，可以记住迭代的位置

"""

nums = [3, 8, 12, 54, 2, 7]

it = iter(nums) # 调用iter()函数创建迭代器

print(type(it))

print(next(it)) # 调用next()函数获取迭代器的下一个元素

print(next(it)) # 只能往前不能后退

# 使用for...in循环遍历迭代器

for i in it:

print(i)

"""

生成器generator：在循环过程中依次计算获取值的对象（节省空间、效率高）

创建生成器的方式：

方式1：把一个列表生成式的[]改成()

方式2：在函数中使用yield关键字，此时该函数就变成一个生成器函数

"""

# 方式1：把一个列表生成式的[]改成()

generator = (i for i in range(1, 100))

print(type(generator)) # generator类型

# 获取生成器的下一个值

print(next(generator)) # 获取时才生成值，类似于Oracle中sequence

print(next(generator))

print(next(generator))

# 使用for...in循环遍历生成器

for i in generator:

print(i)

print("-" * 80)

# 方式2：在函数中使用yield关键字，此时该函数就变成一个生成器函数

def gen():

print("one")

yield 13

print("two")

yield 8

print("three")

yield 25

print("four")

yield 38

# 生成器函数与普通函数的执行流程不一样：

# 普通函数是顺序执行，执行到最后一行或遇到return时结束

# 生成器函数是在每次调用next()时执行，遇到yield语句就返回，下一次调用next()时会从上次返回的yield语句处继续执行

g = gen() # generator类型

print(type(g))

print(next(g))

print(next(g))

# 使用for...in循环遍历生成器

for i in g:

print(i)

​ 高阶函数

"""

高阶函数：一个函数接收另一个函数作为参数，这种函数称为高阶函数

"""

nums = [12, -4, 3, -23, 65, 1, -234, 22]

# 定义一个函数，用来检查数字是否大于5

def f1(x):

if x > 5:

return True

return False

# 自定义高阶函数，用来过滤列表中的元素

def fn(fun, lst):

"""

将列表中所有符合条件的元素筛选出来，返回一个新列表

:param fun: 条件函数

:param lst: 要进行筛选的列表

:return: 返回新列表

"""

new_list = []

for i in lst:

if fun(i):

new_list.append(i)

return new_list

nums1 = fn(f1, nums)

print(nums1)

def f2(x):

return x % 2 == 0

print(fn(f2, nums))

# 内置高阶函数 filter()，用于过滤序列

nums2 = filter(f1, nums)

print(list(nums2))

# 内置高阶函数 map()，用于处理序列

def f3(x):

return x * x

nums3 = map(f3, nums)

print(list(nums3))

# 内置高阶函数 sorted()，用于排序

print(sorted(nums))

print(sorted(nums,key=abs))

​ 匿名函数和装饰器

"""

匿名函数：没有名字的函数，使用lambda关键字

"""

nums = [12, 4, 32, 5, 23, 7]

# def fn(x):

# return x * 2 + 1

nums_new = list(map(lambda x: x * 2 + 1, nums))

print(nums_new)

# 将匿名函数赋给变量（不建议）

a = lambda x: x + 1

print(a(2))

print("-" * 80)

"""

装饰器：在代码运行期间动态增加功能，称为装饰器Decoration，类似于AOP

"""

# 定义一个装饰器，为函数添加打印日志的功能

def log(fn):

def wrapper(*args, **kwargs):

print("开始执行%s()函数。。。" % fn.__name__)

res = fn(*args, **kwargs)

print("执行%s()函数结束。。。" % fn.__name__)

return res

return wrapper # 返回装饰函数

@log

def even(lst):

for i in lst:

if i % 2 == 0:

print(i)

@log

def calc(num1, num2):

res = num1 + num2

return res

even([12, 34, 2, 5, 34, 21])

print(calc(3, 5))

五、面向对象

1. 定义类

​ 语法：

class 类名：

类中成员

​ 类中的成员：实例属性、实例方法、类属性、类方法、静态方法等

# 定义一个类，使用class关键字

class Student:

# pass

# 类属性：直接在类中定义的属性，可以通过类或实例对象来访问

hobby = "吃饭"

# 实例方法：将self作为第一个参数的方法

def say_hi(self): # self表示当前类的实例，类似于java中的this

print("Hi:" + self.name)

def say_hello(self, username="无名氏"):

print("Hello:" + username)

# 类方法：使用@classmethod修饰的方法，将cls作为第一个参数

@classmethod

def show(cls, msg): # cls表示当前类

print(msg, cls.hobby)

# 静态方法：使用@staticmethod修饰的方法，没有任何必选参数，不需要将cls作为第一个参数

@staticmethod

def show2(msg):

print(msg, Student.hobby)

# 创建类的对象

stu1 = Student() # 创建Student类的一个实例

stu2 = Student()

print(stu1, type(stu1))

print(stu2, type(stu2))

a = 3

print(a, type(a))

b = int(5) # 创建int类的一个实例

c = str("hello") # 创建str类的一个实例

print(b, type(b))

# 为对象绑定属性

stu1.name = "tom" # 实例属性，通过实例对象添加的属性

stu1.age = 20

stu2.name = "alice"

stu2.sex = "female"

stu2.height = 180.5

print(stu1.name, stu1.age)

print(stu2.name, stu2.sex, stu2.height)

# 访问实例方法

stu1.say_hi() # 调用方法时无需传递self，由解析器调用时将对象作为self自动传入

stu2.say_hi()

stu1.say_hello("张三")

stu2.say_hello()

# 访问类属性

print(Student.hobby)

stu1.hobby = "睡觉" # 为stu1添加了一个实例属性，并不会改变类属性hobby的值

print(stu1.hobby)

print(stu2.hobby) # 如果当前实例没有hobby属性，则会向上查找类属性hobby

# 访问类方法

Student.show("hello") # 调用方法时无需传递cls

stu1.show("Hello")

Student.show2("您好")

stu2.show2("你好")

2. 构造方法

​ __init__() 构造方法，在创建对象时会自动调用，可以用来初始化对象的属性

class Student:

# 构造方法（函数），不支持重载

def __init__(self, name, age):

print("创建对象，执行构造方法。。。")

self.name = name

self.age = age

# 实例方法

def show(self):

print("姓名：%s，年龄：%d" % (self.name, self.age))

stu1 = Student("tom", 18)

print(stu1.name, stu1.age)

stu1.show()

3. 封装、继承、多态

​ 封装：隐藏对象中一些不希望被外部所访问到的属性，保证数据的安全

class Student:

# 定义私有属性

__age = 18 # 以两个下划线开头，表示对象的隐藏属性，只能在类内部访问

# 提供getter/setter方法

def get_age(self):

return self.__age

def set_age(self, age):

# 判断数据是否有效

if 0 < age < 100:

self.__age = age

else:

self.__age = 18

stu1 = Student()

# print(stu1.__age) # 在类外部无法访问私有属性

stu1.set_age(28)

print(stu1.get_age())

# 其实Python会把私有属性转为 _类名__属性名（强烈不建议）

print(stu1._Student__age)

​ 继承：使一个类能够获取到其他类中的属性和方法

# 定义一个Person类，父类（超类、基类）

class Person(object): # 如果省略了父类，则默认父类为object

def __init__(self, name):

self.name = name

def run(self):

print("person:" + self.name + "正在奔跑。。。")

# 定义一个Student类，子类

class Student(Person): # 继承自Person

def __init__(self, name, email):

# 调用父类的构造方法

# Person.__init__(name) # 方式1：直接指定父类的构造方法

super().__init__(name) # 方式2：使用super，推荐

self.email = email

# 定义子类特有的方法

def study(self):

print("student:" + self.name + "正在学习。。。")

def show(self):

print("姓名：%s，邮箱：%s" % (self.name, self.email))

# 重写父类的方法

def run(self):

# super().run() # 调用父类的方法

print("student:" + self.name + "正在奔跑。。。。")

stu = Student("tom", "[email protected]")

stu.run() # 调用子类重写后的方法

stu.study()

stu.show()

# 判断一个对象是否是指定类的实例，即判断对象的类型

print(isinstance(stu, Student))

print(isinstance(stu, Person))

# 判断一个类是否是指定类的子类

print(issubclass(Student, Person))

print(issubclass(Student, object))

# object类是所有类的根类，默认所有类都继承自object

print(stu.__doc__)

print(stu.__dict__)

​ 多继承

class A:

def a(self):

print("a")

class B:

def b(self):

print("b")

class C(A, B): # 继承多个父类，以逗号隔开

def c(self):

print("c")

c = C()

c.a()

c.b()

c.c()

# 类的特殊属性 __bases__ 可以用来获取当前类的所有父类

print(C.__bases__)

​ 多态：多种形态

class Animal:

def __init__(self, name):

self.name = name

def cry(self):

print("动物在叫。。。。")

class Dog(Animal):

def __init__(self, name, age):

super().__init__(name)

self.age = age

def cry(self):

print("狗在叫。。。。汪汪汪")

class Cat(Animal):

def __init__(self, name, sex):

super().__init__(name)

self.sex = sex

def cry(self):

print("猫在叫。。。喵喵喵")

# 一个对象可以以不同的形式去呈现，就是多态

def play(animal):

print(animal.name)

animal.cry()

dog = Dog("旺财", 2)

cat = Cat("猫咪", "公")

play(dog)

play(cat)

4. 魔术方法

​ 在类中可以定义一些特殊的方法，称为魔术方法

​ 特点：

都是以双下划线开头，以双下划线结尾

不需要手动调用，在特定时机会自动执行

# 定义一个类

class Person(object):

def __init__(self, name, age):

print("__init__")

self.name = name

self.age = age

# 将对象转换为字符串时调用，类似于java中的toString()

def __str__(self):

return "Person [name=%s, age=%d]" % (self.name, self.age)

# 在对象使用len()函数时调用

def __len__(self):

return len(self.name)

# 在对象使用repr()函数时调用

def __repr__(self):

return "hello person"

# 将对象转换为bool类型时调用

def __bool__(self):

return self.age > 18

# 在对象进行大于比较时调用

def __gt__(self, other): # self表示当前对象，other表示要比较的对象

return self.age > other.age

p1 = Person("唐伯虎", 20)

p2 = Person("秋香", 18)

print(p1)

print(len(p1))

print(repr(p1))

print(bool(p1))

if p1:

print(p1.name, "已成年")

else:

print(p1.name, "未成年")

print(p1 > p2)

六、模块

1. 简介

​ 模块化是指将一个程序分解为一个个的模块module，通过组合模块来搭建出一个完整的程序

​ 优点：便于团队开发、方便维护、代码复用

​ 在Python中一个.py文件就是一个模块，创建模块实际上就是创建一个.py文件，可以被其他模块导入并使用

​ 注意：

自定义模块时要注意命名规范，使用小写，不要使用中文、特殊字符等

不要与内置模块冲突

2. 使用模块

​ 导入模块的两种方式：

方式1：import 包名.模块名 [ as 别名]

方式2：from 包名 import 模块名

​ from 包名.模块名 import 变量|函数|类

​ 导入模块的代码可以放在任意位置，但一般都放在程序的开头

# 方式1

# import py04_模块.mymodule

# print(py04_模块.mymodule.a) # 调用模块中的变量

# print(py04_模块.mymodule.plus(3, 5))

# import py04_模块.mymodule as m

# print(m.plus(3, 5))

# 方式2

# from py04_模块 import mymodule

# print(mymodule.b)

# print(mymodule.minus(8, 2))

from py04_模块.mymodule import b, plus, Calculator

# from py04_模块.mymodule import * # 不建议

# print(b)

# print(plus(2, 5))

# print(Calculator.sum(3, 12, 5))

"""

__name__属性是模块的内置属性，每个模块中都有该属性

当该.py文件是主执行文件，直接被执行时，其值为__main__

当该.py文件是被调用，导入执行时，其值为模块名

"""

# print(__name__)

# 程序入门，类似于Java中的main()方法，只在当直接调用该文件时才会执行，用来执行测试

if __name__ == "__main__":

print(Calculator.sum(1, 2, 3))

3. Python标准库

​ Python提供了一个强大的标准库，内置了许多非常有用的模块，可以直接使用（标准库是随Python一起安装）

​ 常用的内置模块：

sys：获取Python解析的信息

os：对操作系统进行访问，主要是对目录或文件进行操作

math：数学运算

random：生成随机数

datetime：处理日期和时间，提供了多个类

time：处理时间

import sys

import os

import math

import random

from datetime import datetime, timedelta

import time

print(sys.version) # Python版本

print(sys.platform) # 系统平台

print(sys.argv) # 命令行参数

print(sys.path) # 模块搜索路径，包含了Python解析器查找模块的搜索路径

print(sys.modules) # 显示当前程序中引入的所有模块

print(sys.getdefaultencoding()) # 默认字符集

# sys.exit("程序退出") # 退出解析器

print("---------------------------------")

print(os.name) # 操作系统的类型

print(os.environ["path"]) # 系统的环境变量

print(os.getcwd()) # 当前的目录

print(os.listdir("d:/")) # 列出指定目录中的内容

# os.system("ping www.baidu.com") # 执行系统命令

print(os.path.exists("d:/soft")) # 判断路径是否存在

print("---------------------------------")

print(math.pi)

print(math.ceil(3.4))

print(math.floor(3.4))

print(math.pow(2, 3))

print(math.trunc(2.6)) # 截尾取整

print(round(2.6))

print(round(3.1415925, 3)) # 四舍五入，保留三位小数

print("---------------------------------")

print(random.random()) # 返回[0,1)之间的随机浮点数

print(random.randint(1, 101)) # 返回[1,100]之间的随机整数

print(random.sample([1, 21, 54, 23, 6, 2], 2)) # 从数组中返回随机两个元素

print("---------------------------------")

print(datetime.now(), type(datetime.now())) # 返回当前时间

print(datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")) # 将datetime转换为指定格式的str

print(datetime.strftime(datetime.now(), "%Y{0}%m{1}%d{2} %H:%M:%S").format("年", "月", "日"))

print(datetime.strptime("2018-2-14", "%Y-%m-%d")) # 将str转换为datetime

print("明天：", datetime.now() + timedelta(days=1)) # timedelta表示两个时间之间的时间差，可以用来进行日间的加减操作

print("前一秒：", datetime.now() - timedelta(seconds=1))

print("---------------------------------")

print(time.time()) # 返回当前时间的时间戳

print(int(time.time())) # 秒级时间戳

print(int(time.time() * 1000)) # 毫秒时间戳

time.sleep(5) # 休眠5秒

print(1111)

4. 第三方模块

​ Python社区提供了大量的第三方模块，使用方式与标准库类似

​ 安装第三方模块：

使用包管理工具pip（随Python一起安装的）

pip install 模块名

使用PyCharm来安装

Settings——>Project——>Project Interpreter

报错：AttributeError: module "pip" has no attribute "main"

解决：找到PyCharm安装目录下的helpers/packaging_tool.py文件，替换其中的do_install和do_uninstall函数

​ pyecharts是一个用于Echarts图表的类库，便于在Python中根据数据生成可视化的图表

​ Echarts是百度开源的一个数据可视化JS库，主要用来进行数据可视化。

​ 安装pyecharts库

​ 新版本的pyecharts默认不带地图文件，如果需要使用地图，需要自行安装地图文件包

七、异常处理和IO操作

1. 异常处理

​ 语法：

try:

可能出现异常的代码

except:

出现异常后要执行的操作

else:

不出现异常时执行的操作

finally:

无论是否出现异常都必须要执行的操作

try:

print("try...")

a = 5 / int("abc")

# except: # 捕获所有异常

# except ZeroDivisionError as e: # 捕获ZeroDivisionError异常，获取到异常对象

except (ZeroDivisionError, ValueError, Exception) as e: # 捕获多种异常

print("出现异常啦", e)

else:

print("没有异常时执行")

finally:

print("finally...")

# 自定义异常，继承自Exception(Exception类是所有异常类的父类)

class UsernameExistsException(Exception):

pass

def fn(username):

if username == "admin" or username == "tom":

raise UsernameExistsException("用户名已存在") # 使用raise抛出异常

else:

print("ok")

fn(input("请输入用户名："))

2. IO操作

​ 文件操作

"""

读写模式：

r 读模式

w 写模式（覆盖）

a 追加模式

r+ 读写模式

b 二进制模式

"""

# ----读取文件

try:

f = open("itany.txt", mode="r", encoding="utf-8") # 打开一个文件，返回一个对象，这个对象就代表着当前打开的文件

print(f.read()) # 一次性读取所有内容

except FileNotFoundError as e:

print("文件找不到：", e)

finally:

if f:

f.close() # 文件操作后一定要关闭

print("-" * 80)

# 简写，使用with...as语句，会自动调用close()

with open("itany.txt", mode="r", encoding="utf-8") as f:

# print(f.read())

# print(f.read(3)) # 每次读取3个字符

# print(f.read(3))

# print(f.readline().strip()) # 每次读取一行

# print(f.readline())

lines = f.readlines() # 一次性读取所有行，返回list

# print(lines)

for line in lines:

print(line.strip())

print("-" * 80)

# ----写文件

with open("itany.txt", mode="a", encoding="utf-8") as f:

f.write("xxx ")

f.write("yyy")

print("-" * 80)

# ----读写二进制文件

with open("baidu.png", mode="rb") as f:

with open("itany.png", mode="wb") as out:

out.write(f.read())

print("拷贝成功")

​ 文件操作模块

import os

impor