目录
一、简介1.1、概念1.2、数据类型1.2.1、介绍1.2.2、常用转换函数
二、循环控制2.1、三元条件运算符2.2、while循环2.3、 for循环2.4、循环嵌套
三、切片四、集合4.1、列表4.1.1、创建方式4.1.2、常见操作
4.2、元组4.2.1、创建方式4.2.2、常见操作
4.3、字典4.3.1、创建方式4.3.2、常见操作
4.4、序列解包4.5、常见字符串操作
五、OS模块5.1、系统操作5.2、路径操作5.3、文件读写5.4、shuitl模块5.5、open模块
六、函数6.1、定义6.2、变量作用域6.3、默认参数6.4、可变参数6.5、高阶函数6.6、闭包6.7、装饰器
七、类与对象7.1、定义7.2、属性与方法7.3、常见内置方法7.4、运算符与类专有方法7.5、私有属性与方法7.6、isinstance()函数7.7、继承
一、简介
1.1、概念
python是一门强类型的动态脚本语言 强类型：不允许不同类型相加，否则会报错
123 + 'abc'
Traceback (most recent call last
):
File
"D:/3.dev/pyworkspace/test02/py_00_control.py", line
2, in <module
>
123 + 'abc'
TypeError
: unsupported operand
type(s
) for +: 'int' and
'str'
动态语言：不显示声明数据类型，赋值时确定一个变量的类型
# 代码无需大括号，通过缩进方式编写（
4个空格）
abc
= 10
if abc
== 10:
print("hello 1")
# 这里再次给abc赋值不同类型值不换报错，只是改变了变量类型
abc
= '10'
if abc
== 10:
print("hello 2")
else:
print("world")
hello
1
world
脚本语言：指运行代码只需要解释器，不需要编译器
1.2、数据类型
1.2.1、介绍
基本类型
number类型：整型Int、长整形long、浮点数float、复数complex
boolean类型：true、false
String类型：
高级类型
元组tuple：内部元素不可修改
列表List：内部元素可修改
集合Set：内部元素无序
字典dict：key-value形式
1.2.2、常用转换函数
int(x,[base])：将x转换为整数 long(x,[base])：将x转换为长整数 float(x)：将x转换为浮点数 str(x)：将x转换为字符串 tuple(s)：将序列s转为元组 list(s)：将序列s转为列表 set(s)：将序列s转为set集合 dict(d)：创建字典，d必须为一个序列（key,value）元组
二、循环控制
2.1、三元条件运算符
格式：A=Y if X else Z
num
=int(input('输入一个整数：'))
print(num
if num
> 100 else '输入值小于100')
输入一个整数：
10
输入值小于
100
2.2、while循环
count
= 0
while count
<= 9:
print(count
, end
=' ')
if count
== 10:
break
count
+= 1
else:
print('end')
0 1 2 3 4 5 6 7 8 9 end
2.3、 for循环
values
= ['A', 'B', 'C', 'D']
for value
in values
:
print(value
, end
=' ')
values
= ['A', 'B', 'C', 'D']
for i
in range(len(values
)):
print(values
[i
], end
=' ')
A B C D A B C D
2.4、循环嵌套
# 九九乘法表
j
= 1
while j
<= 9:
i
= 1
while i
<= j
:
print('%d*%d=%d' % (i
, j
, i
*j
), end
='\t')
i
+= 1
print()
j
+= 1
for j
in range(1, 10):
for i
in range(1, j
+1):
print('%d*%d=%d' % (i
, j
, i
*j
), end
='\t')
i
+= 1
print()
j
+= 1
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
三、切片
切片操作是从一个父列表（元组、字符串）中，获取一个子集； 格式：列表[start:end[:step]] start表示开始偏移量，end表示终止偏移量，step表示步长
my_list
= [1, 2, 3, 4, 5]
# 取全部值
print(my_list
[:])
# 从下标
2开始取值
print(my_list
[2:])
# 取下标
2前面的值
print(my_list
[:2])
# 取下标
1到
5，且步长为
2的值
print(my_list
[1:5:2])
# 步长为负数，反向提取
print(my_list
[::-1])
# 从倒数第二个开始取值
print(my_list
[-2:])
[1, 2, 3, 4, 5]
[3, 4, 5]
[1, 2]
[2, 4]
[5, 4, 3, 2, 1]
[4, 5]
四、集合
4.1、列表
4.1.1、创建方式
# 直接创建
my_list
= [1, 2, 3, 'a', 'b', 'c']
print(my_list
)
#
使用list()函数创建
my_list
= list('abc')
print(my_list
)
#
使用range()函数创建 格式：range
[[start
,] end
[,step
]] end必须，其它可选
my_list
= list(range(1, 10, 2))
print(my_list
)
# 使用推导式生成
my_list
= [x
for x
in range(1, 10, 3)]
print(my_list
)
my_list
= [x
*2 for x
in range(1, 10, 3)]
print(my_list
)
[1, 2, 3, 'a', 'b', 'c']
['a', 'b', 'c']
[1, 3, 5, 7, 9]
[1, 4, 7]
[2, 8, 14]
4.1.2、常见操作
#
append()添加元素
my_list
= [1, 2, 3]
my_list
.append('a')
print(my_list
)
# 列表相
+，会创建一个新的列表对象
my_list02
= [4, 5, 6]
print(my_list
+ my_list02
)
#
extend()追加列表，与
+相比，不会创建新的列表对象
my_list
.extend(my_list02
)
print(my_list
)
#
insert() 插入元素
my_list
.insert(5, 'kk')
print(my_list
)
#
index()获取指定元素在列表中首次出现的索引
print(my_list
.index(3))
#
del()删除指定位置元素
del my_list
[1]
print(my_list
)
#
pop()弹出指定位置元素，默认弹出最后一个元素
print(my_list
.pop())
#
remove() 直接删除元素
a
= [1, 2, 3, 4, 5, 1]
a
.remove(2)
print(a
)
# 乘法 即复制几份元素
print(a
* 2)
#
len()、max()、min()函数
print(len(a
))
print(max(a
))
print(min(a
))
#
count() 统计某个元素在列表中出现次数
print(a
.count(1))
#
copy() 列表复制
print(a
.copy())
#
sort() 元素排序，会改变原列表
a
.sort()
print(a
)
#
sorted() 元素排序，生成新列表，不会改变原列表
b
= sorted(a
)
print(b
)
#
reverse() 将元素反向存放
a
.reverse()
print(a
)
#
clear() 清空列表内容
a
.clear()
print(a
)
[1, 2, 3, 'a']
[1, 2, 3, 'a', 4, 5, 6]
[1, 2, 3, 'a', 4, 5, 6]
[1, 2, 3, 'a', 4, 'kk', 5, 6]
2
[1, 3, 'a', 4, 'kk', 5, 6]
6
[1, 3, 4, 5, 1]
[1, 3, 4, 5, 1, 1, 3, 4, 5, 1]
5
5
1
2
[1, 3, 4, 5, 1]
[1, 1, 3, 4, 5]
[1, 1, 3, 4, 5]
[5, 4, 3, 1, 1]
[]
4.2、元组
4.2.1、创建方式
# 直接创建
a
= 1, 2, 3, 4, 5
print(a
)
a
= (1, 2, 3, 4, 5)
print(a
)
#
使用tuple()函数创建
a
= tuple((1, 2, 3, 4, 5))
print(a
)
a
= tuple(range(5))
print(a
)
a
= tuple('12345')
print(a
)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
(0, 1, 2, 3, 4)
('1', '2', '3', '4', '5')
4.2.2、常见操作
#
sorted() 排序
a
= (1, 5, 3, 2, 4)
b
= sorted(a
)
print(b
)
#
zip(列表
1, 列表
2, 列表
3) 将多个列表对应位置的元素组合成为元组
a
= [1, 2, 3]
b
= ['a', 'b', 'c']
c
= zip(a
,b
)
print(list(c
))
# 生成器使用
s
= (x
for x
in range(10))
print(tuple(s
))
[1, 2, 3, 4, 5]
[(1, 'a'), (2, 'b'), (3, 'c')]
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
4.3、字典
4.3.1、创建方式
# 直接创建
d
= {'name':'zhangsan', 'age':18}
print(d
)
d
= dict(name
='zhangsan', age
=18)
print(d
)
d
= dict([('name','zhangsan'),('age',18)])
print(d
)
#
通过fromkeys()创建值为空的字典
d
= dict
.fromkeys(['name', 'age'])
print(d
)
{'name': 'zhangsan', 'age': 18}
{'name': 'zhangsan', 'age': 18}
{'name': 'zhangsan', 'age': 18}
{'name': None
, 'age': None
}
4.3.2、常见操作
# 取值
d
= {'name':'zhangsan', 'age':18}
print(d
['name'])
print(d
.get('name'))
# 新增与修改 键不存在则新增，存在则修改
d
['sex']='M'
print(d
)
#
update() 使用一个字典更新另一个字典，如果key重复则覆盖
d1
= {'name':'zhangsan', 'age':18}
d2
= {'age':20, 'sex':'M'}
d1
.update(d2
)
print(d1
)
#
items()元组形式返回key
-value，keys()元组形式返回key，values()元组形式返回value
d
= {'name':'zhangsan', 'age':18}
print(d
.items())
print(d
.keys())
print(d
.values())
for key
in d
.keys():
print(key
)
zhangsan
zhangsan
{'name': 'zhangsan', 'age': 18, 'sex': 'M'}
{'name': 'zhangsan', 'age': 20, 'sex': 'M'}
dict_items([('name', 'zhangsan'), ('age', 18)])
dict_keys(['name', 'age'])
dict_values(['zhangsan', 18])
name
age
4.4、序列解包
a
,b
,c
= [1, 2, 3]
print(a
)
print(b
)
print(c
)
1
2
3
4.5、常见字符串操作
s
= 'hello world'
# 替换所有指定字符
s1
= s
.replace('l', 'L')
print(s1
)
# 替换指定前n个字符（这里是前
2个）
s2
= s
.replace('l', 'L', 2)
print(s2
)
heLLo worLd
heLLo world
五、OS模块
os模块可以直接调用操作系统，操作文件和目录
5.1、系统操作
import os
# ping百度地址
os
.system("ping www.baidu.com")
# 访问
QQ浏览器
os
.system(r
"D:\3.dev\soft\qqliulanqi\QQBrowser\QQBrowser.exe")
# 安装xxx程序
os
.startfile(r
"D:\3.dev\soft\xxx.exe")
5.2、路径操作
import os
# 打印当前工作目录路径
print(os
.getcwd())
# 打印当前目下的文件
/文件夹列表
print(os
.listdir(os
.getcwd()))
# 命令操作
os
.chdir('../')
print(os
.getcwd())
D:\
3.dev\pyworkspace\test02
['.idea', 'py_00_control.py', 'py_01_object.py', 'py_02_basic_operations.py', 'venv']
D:\
3.dev\pyworkspace
5.3、文件读写
import os
if not os
.path
.exists('a'):
# 创建文件夹
os
.mkdir('a')
# 重命名
os
.rename('a', 'b')
# 创建多级目录
os
.makedirs('aa1/aa2/aa3')
# 多级目录重命名
os
.renames('aa1/aa2/aa3', 'bb1/aa2/aa3')
5.4、shuitl模块
用来对文件进行拷贝、解压缩、移动、删除等操作
import shutil
# 复制文件
shutil
.copyfile('1.txt', '2.txt')
# 将a目录下b目录中的所有文件，复制到c目录中（处理
.js和
.css文件）
shutil
.copytree('a/b', 'c', ignore
=shutil
.ignore_patterns("*.js", ".css"))
5.5、open模块
open()方法用于打开一个文件，并返回文件对象 常见格式：open(url, w/a)， w：以写的方式打开文件 a：以追加的方式打开文件 常用方法 file.close()：关闭文件 file.flush()：刷新缓冲区，直接一次性将缓冲区数据写入文件， file.next()：返回下一行 file.read([size])：读取指定字节数据 file.readline()：读取一行数据（包括’\n’符号） file.readlines()：读取所有行 file.write()：写入数据到文件
# 写数据
s
= 'hello world'
f
= open('./1.txt', 'w', encoding
='utf-8')
f
.write(s
)
f
.close()
# 读数据
try:
f1
= open('./1.txt', 'r', encoding
='utf-8')
s1
= f1
.read()
print(s1
)
finally:
if f1
:
f1
.close()
# 读取指定字符数
with open('./1.txt', 'r', encoding
='utf-8') as f
:
print(f
.read(3))
# 一行行读取
f
= open('./1.txt', 'r')
line
= f
.readline()
while line
:
print(line
)
line
= f
.readline()
f
.close()
# 读取所有行，比较占内存，适合小文件
f
= open('./1.txt', 'r', encoding
='utf-8')
lines
= f
.readlines()
for line
in lines
:
print(line
)
f
.close()
# 一行行写入
my_list
= ['aaaa哈哈\n', 'bbbb啊啊\n', 'cccc咔咔\n']
f
= open('./2.txt', 'w+', encoding
='utf-8')
f
.writelines(my_list
)
f
.seek(0) # 将文件指针移到文件开始位置
read_list
= f
.readlines()
for line
in read_list
:
print(line
.strip()) # 去掉末尾换行符
f
.close()
hello world
hel
hello world
hello world
aaaa哈哈
bbbb啊啊
cccc咔咔
六、函数
6.1、定义
def
函数名称([param1
, param2
...]):
....
[return 表达式
]
def
testSum(a
, b
):
return a
+ b
print(testSum(1,2))
def
testUser(name
, age
):
print('姓名{0}，年龄{1}'.format(name
, age
))
print('姓名%s，年龄%d' % (name
, age
))
testUser('张三', 18)
3
姓名张三
,年龄
18
姓名张三，年龄
18
6.2、变量作用域
# 全局变量
c
= 1
def
testSum(a
):
# 局部变量
b
= 2
# 就近原则
c
= 2
return a
+b
+c
print(testSum(1))
print(c
)
# 使用global关键字改变全局变量的值
def
changeC():
global c
c
= 2
changeC()
print(c
)
5
1
2
6.3、默认参数
# 默认参数，不传值时使用默认参数值
def
test(a
=1, b
=2):
print(a
+b
)
test()
test(2, 3);
3
5
6.4、可变参数
# 可变参数，在参数名前加一个
*号表示将多个参数收集到一个元组对象中，两个
**号则是放到字典中
def
test1star(a
, b
, *c
):
print(c
)
test1star(1, 2, 3, 4, 5)
def
test2star(a
, b
, **c
):
print(c
)
test2star(1, 2, c1
=3, c2
=4, c3
=5)
(3, 4, 5)
{'c1': 3, 'c2': 4, 'c3': 5}
6.5、高阶函数
指函数中的参数不仅可以是变量，也可是另一个函数，即函数式编程
def
test1(a
):
return a
*a
def
test2(fun
,b
):
return fun
* b
print(test2(test1(2),5))
20
6.6、闭包
在python中，闭包意味着嵌套定义，内部函数使用外部函数中定义的变量，外部函数返回内部函数名； 如果调用一个函数X，而函数X返回一个函数Y，那么函数就称为闭包； 定义示例
# 基本格式
def
funX(param1
):
def
funY(param2
):
return param1
* param2
return funY
f
= funX(2)
print(f(3))
# 闭包传入函数
def
log(fun
):
def
wrapper(a
, b
):
fun('姓名{0}，年龄{1}'.format(a
, b
))
return wrapper
f
= log(print
)
f("张三", "18")
6
姓名张三，年龄
18
6.7、装饰器
装饰器本质是一直闭包，使用@符号定义实现，格式：@装饰器名称，装饰器定义在函数或类上
# 日志装饰器
import time
def
writeLog(func
):
try:
f
= open('./1.txt', 'a')
f
.write(func
.__name__
)
f
.write('\t')
f
.write(time
.asctime())
f
.write('\n')
except Exception
as e
:
print(e
.args
)
finally:
f
.close()
# 在不修改源代码基础上，添加日志功能
def
log_decorator(fun
):
def
wrapper():
# 添加调用日志功能的方法
writeLog(fun
)
fun()
return wrapper
@log_decorator
def
fun1():
print('hello 1')
@log_decorator
def
fun2():
print('hello 2')
fun1()
fun2()
fun1 Thu Oct
29 23:02:27 2020
fun2 Thu Oct
29 23:02:27 2020
七、类与对象
python不仅支持面向过程编程，也支持面向对象编程
7.1、定义
# 格式
class 类名(父类名
):
类体
# pass表示什么都不做，为空语句
class User:
pass
# 定义一个user类
class User:
# 定义构造方法__init__，第一个参数为self
def
__init__(self
, name
, age
):
# 实例属性
self
.name
= name
self
.age
= age
# 实例方法
def
getUserInfo(self
):
return '姓名{0}，年龄{1}'.format(self
.name
, self
.age
)
user
= User('张三', 18)
print(user
.getUserInfo())
7.2、属性与方法
# 类属性
class User:
address
= 'beijing'
#
...省略
print(User
.address
)
# 类方法
class User:
address
= 'beijing'
# 指定类方法注解
@classmethod
def
getAddress(self
):
return self
.address
print(User
.getAddress())
7.3、常见内置方法
def __init__(self):初始化对象，在创建新对象时调用 def __del__(self):释放对象，在对象被删除之前调用 def __new__(cls, *args, **kwargs):实例的生成操作 def __str__(self):在使用print语句时调用 def __getitem__(self, item):获取序列索引key对应的值，相当于seq[key] def __len__(self):调用内联函数len() def __getattr__(self, item):获取属性值 def __setattr__(self, key, value):设置属性值 def __gt__(self, other):判断self是否大于other def __lt__(self, other):判断self是否小于other def __ge__(self, other):判断self是否大于或等于other def __eq__(self, other):判断self是否等于other def __call__(self, *args):将实例对象当做函数调用
7.4、运算符与类专有方法
加减法： +与 __add__、 -与__sub__ 比较符： <与 __lt__、 <=与 __le__、 >与 __gt__、 >=与 __ge__、 ==与 __eq__、 !=与 __ne__ 异或与： |与 __or__、 ^与 __xor__、 &与 __and__ 位移： <<与 __lshift__、 >>与 __rshift__ 其它计算： *与 __mul__、 /与 __truediv__、 %与 __mod__（取余）、 //与 __floordiv__（整数除）、 **与 __pow__（指数运算）
# 示例
a
= 2
b
= 3
print(a
.__add__(b
))
print(a
.__sub__(b
))
print(a
.__mul__(b
))
print(a
.__truediv__(b
))
print(a
.__pow__(b
))
print(a
.__gt__(b
))
print(a
.__eq__(b
))
print(a
.__lt__(b
))
5
-1
6
0.6666666666666666
8
False
False
True
7.5、私有属性与方法
语法：两个下划线__开头的为私有属性/方法 类内部可以直接访问，类外部使用 _类__私有属性/方法方式访问
class User:
phone
= '18866667777'
__address
= 'beijin' # 私有类属性
def
__init__(self
,name
,age
):
self
.name
= name
self
.__age
= age # 私有实例属性
def
getUserName(self
):
return '姓名{0}'.format(self
.name
)
def
__getUserAge(self
): # 私有方法
return '年龄{0}'.format(self
.__age
)
user
= User('张三', 18)
print(User
.phone
)
print(user
.name
)
print(user
.getUserName())
#
print(user
.__age
) # 报错
#
print(user
.__getUserAge
) # 报错
18866667777
张三
姓名张三
Traceback (most recent call last
):
File
"D:/3.dev/pyworkspace/test02/py_00_control.py", line
489, in <module
>
print(user
.__age
) # 报错
AttributeError
: 'User' object has no attribute
'__age'
7.6、isinstance()函数
与type()函数类似，用于判断对象类型，格式：isinstance(object, classinfo)
s
= 'hello'
print(type(s
))
print(isinstance(s
, str
))
print(isinstance(s
, int
))
print(isinstance(s
, (str
, int
, list
))) # 判断s是否在元组中
<class 'str'>
True
False
True
7.7、继承
python支持多继承
# 格式
class 子类(父类
):
类体
class Person:
def
eat(self
):
print("人可以吃饭")
def
sleep(self
):
print("人需要睡觉")
class User(Person
):
def
shop(self
):
print("用户喜欢购物")
# 方法重写
def
sleep(self
):
print('人一天需要睡8小时')
user
= User()
user
.eat()
user
.shop()
user
.sleep()
人可以吃饭
用户喜欢购物
人一天需要睡
8小时
