Python3教程

1、基础篇

1.1 print方法

• 打印print输出方法
  • 默认尾部换行

代码:

print("hello word")
print("默认换行")
print("不想换行:",end="")
print("接着上一行")

结果:

hello wordhello word
默认换行
不想换行:接着上一行

1.2 数据类型

1.2.1 整形（int）

• int（有符号整型）
• long（长整型[也可以代表八进制和十六进制]）
• float（浮点型）
• complex（复数）

代码示例:

valueInt  = 100
print("valueInt的数据类型为", end=":")
# type方法查看数据类型
print(type(valueInt))
print(valueInt)

结果：

valueInt的数据类型为:<class 'int'>
100

1.2.2 字符串(String)

• 字符串:用单引号或者双引号、三引号表示的字符，数据类型为String
• 字符串可以使用+、*等运算符做字符串拼接

代码示例:

valueString = "100"
valueString2 = '100'
valueString3 = """
123
wer
sadf
"""
valueString4 = '''
aefa
234
faw
fawef'''
print("valueString的数据类型为", end=":")
print(type(valueString))
print(valueString)
print("valueString2的数据类型为", end=":")
print(type(valueString2))
print(valueString2)
print(valueString3)
print(valueString4)
print("faefa'faefa")
print('faefa"faefa')
print("he"+"llo")

结果:

valueString的数据类型为:<class 'str'>
100
valueString2的数据类型为:<class 'str'>
100

123
wer
sadf


aefa
234
faw
fawef
faefa'faefa
faefa"faefa
hello

1.2.3 boolean(布尔)

• 布尔：True或False

代码示例:

a = 1
b = 2
print(a==b)

结果:

False

1.3 数据类型转换

• 所有正整形转换为bool型都为True,负整形为False
• 只有空字符串转换为bool为False其他都是True

代码示例:

a = 1
b = "88888"
print("a的数据类型为", end=":")
print(type(a))
print("b的数据类型为", end=":")
print(type(b))
intB = int(b)
print("intB的数据类型为", end=":")
print(type(intB))
print("intB的值为", end=":")
print(intB)
strA = str(a)
print("strA的数据类型为", end=":")
print(type(strA))
print("strA的值为:"+strA)

结果:

a的数据类型为:<class 'int'>
b的数据类型为:<class 'str'>
intB的数据类型为:<class 'int'>
intB的值为:88888
strA的数据类型为:<class 'str'>
strA的值为:1

1.4 变量及其命名规范

• 变量格式: 【变量名=值】

示例代码：

name = "Python"
old = 3
print(name)
print(old)

结果:

Python
3

• 变量规范
  • 变量名只能由字母、数字、下划线组成
  • 不允许数字开头
  • 不能使用python内置关键字

1.5 注释

• “#”:代表单行注释，不会被编译

• “”""""或者’’’’’’:代表多行注释

  # 这是单行注释
  """
  这是多行注释
  """
  

1.6 输入（input）

• 控制台输入都是字符串类型

代码示例：

name = input("请输入用户名:")
print(name)

结果:

请输入用户名:sumingyang
sumingyang

案例一:在控制台输入两个数字做相加的操作。

代码:

first_number = int(input("请输入第一个数字:"))
two_number = int(input("请输入第二个数字:"))
result = first_number + two_number
print("{}+{}={}".format(first_number, two_number, result))

结果:

请输入第一个数字:14
请输入第二个数字:34
14+34=48

1.7 条件语句

1.7.1 if判断

语法格式：

if 条件1：
	当条件1成立，执行语句1
else
	当条件1不成立，执行语句2

实例代码：

first_number = int(input("请输入第一个数字:"))
two_number = int(input("请输入第二个数字:"))
result = first_number + two_number
# 判断当值大于100时，返回苹果，否则返回梨
if result > 100:
    print("苹果")
else:
    print("梨")

结果:

请输入第一个数字:200
请输入第二个数字:23
苹果

• 多条件判断时，if … elif…else…

  实例代码:

  old = int(input("请输入您的年纪:"))
  if old < 18:
      print("你还未成年，不允许进入！！！")
  elif 18 <= old < 60:
      print("你的身体很棒，可以进去！！！")
  else:
      print("你的年纪太大了，请注意安全！")
  

  结果:

  请输入您的年纪:66
  你的年纪太大了，请注意安全！
  

1.7.2 嵌套条件

需求图：

实例代码:

num = int(input("欢迎来到10086,按1话费相关，按2业务办理，按3人工服务:"))
if num == 1:
    print("欢迎进入话费相关业务")
    cost = int(input("查询话费按1，充值话费按2:"))
    if cost == 1:
        print("您的话费余额为100元！")
    elif cost == 2:
        print("您成功充值50元！")
    else:
        print("您输入的按键有误！")
elif num == 2:
    print("欢迎进入业务办理")
elif num == 3:
    print("欢迎致电人工服务")
else:
    print("请重新输入，运行程序！")

结果:

欢迎来到10086,按1话费相关，按2业务办理，按3人工服务:1
欢迎进入话费相关业务
查询话费按1，充值话费按2:2
您成功充值50元！

1.8 循环语句

1.8.1 while循环

• 只有条件不成立才会终止循环

while 条件:
	执行语句

示例代码:

print("开始")
flag = True
i = 1
while flag:
    print("运行{}次循环体!".format(i))
    if i > 3:
        flag = False
    i += 1

结果:

开始
运行1次循环体!
运行2次循环体!
运行3次循环体!
运行4次循环体!

1.8.2 break 中断程序

代码实例:

print("开始")
flag = True
i = 1
while flag:
    print("运行{}次循环体!".format(i))
    if i > 3:
        flag = False
    i += 1
    break
print(i)

结果:

开始
运行1次循环体!
2

1.8.3 continue

代码示例:

print("开始")
flag = True
i = 1
while flag:
    print("运行{}次循环体!".format(i))
    if i > 3:
        flag = False
    i += 1
    continue
    print("这是被跳过的一行输出")
print(i)
j = 1
flag1 = True
while flag1:
    print("运行{}次循环体!".format(j))
    if j > 3:
        flag1 = False
    j += 1
    print("这是没有被跳过的一行输出")
print(j)

结果:

开始
运行1次循环体!
运行2次循环体!
运行3次循环体!
运行4次循环体!
5
运行1次循环体!
这是没有被跳过的一行输出
运行2次循环体!
这是没有被跳过的一行输出
运行3次循环体!
这是没有被跳过的一行输出
运行4次循环体!
这是没有被跳过的一行输出
5

1.8.4 while else

while 条件:
	语句块
else:
	语句块

代码实例:

num = 1
while num < 5:
    print(num)
    num += 1
else:
    print("结束程序!")

结果:

1
2
3
4
结束程序!

1.9 字符串格式化

1.9.1 %的使用

• %:占位符
• 当字符串中有%时，需要两个%对%进行转义

占位符	类型
%s	字符串
%d	数值类型

代码实例:

name = "sumingyang"
age = 18
print("my name is %s,my old is %d" %(name,age))
message = "%(names)s,你好啊!" %{"names":"lisi"}
# 当字符串中有%时，需要两个%对%进行转义，否则会报错
message1 = "%s,你好啊,这个手机还有%%99的点!" %"zhagnsan"
print(message)
print(message1)

结果:

my name is sumingyang,my old is 18
lisi,你好啊!
zhagnsan,你好啊,这个手机还有%99的点!

1.9.2 format的使用

• {}的顺序按照变量的顺序
• 可以在{}内写上数字进行复用
• 可以自定义名称

代码实例:

text = "我叫{}，我今年{}岁".format("sumingyang",18)
text1 = "我叫{0}，我今年{1}岁,真实的名称是{0}".format("sumingyang",18)
text2 = "我叫{name}，我今年{age}岁,真实的名称是{name}".format(name="sumingyang",age=18)
print(text)
print(text1)
print(text2)

结果:

我叫sumingyang，我今年18岁
我叫sumingyang，我今年18岁,真实的名称是sumingyang
我叫sumingyang，我今年18岁,真实的名称是sumingyang

1.9.3 f的使用

• 可以进制转换

代码示例:

action = "跑步"
age = 18
text = f"我喜欢的运动是{action},今年{age}"
text1 = f"我喜欢的运动是{action},今年{age+2}"
# 转换为16进制
text2 = f"我喜欢的运动是{action},今年{age+2:#x}"
print(text)
print(text1)
print(text2)

结果:

我喜欢的运动是跑步,今年18
我喜欢的运动是跑步,今年20
我喜欢的运动是跑步,今年0x14

1.10 运算符

1.10.1 算术运算符

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

1.10.2 比较运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

1.10.3 赋值运算

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	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

1.10.4 逻辑运算

运算符	逻辑表达式	描述
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

1.10.5 位运算符

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

1.10.6 成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

1.10.7 身份运算符

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

1.10.8 运算符优先级

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 ‘AND’
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

2、增强篇

2.1 字符串的使用案例

实例代码:

• 字符串判断

str1 = "今天天气很糟糕,心情很差!"
print("startswitch:判断字符串以什么开头")
result1 = str1.startswith("今天")
print("result1的结果为:{}".format(result1))

print("endswitch:判断字符串以什么结尾")
result2 = str1.endswith("!")
print("result2的结果为:{}".format(result2))
print("isdecimal:判断字符串是否为十进制数")
str2 = "1235234"
str3 = "你好"
result3 = str2.isdecimal()
result4 = str3.isdecimal()
print("result3的结果为:{}".format(result3))
print("result4的结果为:{}".format(result4))
print("""
center:文字居中
ljust:文字居左
rjust:文字居右
数值-10才会显示对应数量
""")
name = "sumingyang"
data = name.center(13,"=")
data2 = name.ljust(21,"=")
data3 = name.rjust(21,"=")
print(data)
print(data2)
print(data3)

结果:

startswitch:判断字符串以什么开头
result1的结果为:True
endswitch:判断字符串以什么结尾
result2的结果为:True
isdecimal:判断字符串是否为十进制数
result3的结果为:True
result4的结果为:False

center:文字居中
ljust:文字居左
rjust:文字居右

==sumingyang=
sumingyang===========
===========sumingyang

• 字符串切片，索引

代码案例:

name = "sumingyang"
print("len:计算字符长度")
print("name的长度为:{}".format(len(name)))
print("根据字符的索引取值(左包含右不包含,第三个为步长)")
print("name的第一个字符为:{}".format(name[0]))
print("name的最后一个个字符为:{}".format(name[-1]))
print("name的第二个到第四个字符为:{}".format(name[1:4]))
print("name的前五个字符为:{}".format(name[:5]))
print("name的第二和第四字符分别为:{}".format(name[1:4:2]))

结果：

len:计算字符长度
name的长度为:10
根据字符的索引取值(左包含右不包含)
name的第一个字符为:s
name的最后一个个字符为:g
name的第二个到第四个字符为:umi
name的前五个字符为:sumin
name的第二和第四字符分别为:ui

2.2 列表[list]

• (list):是一个有序可变的容器，在里面可以放多个元素

代码案例：

list_demo = ["a","b","c","d"]
print("list_demo的数据类型:{}".format(type(list_demo)))
print(list_demo)
print("append:给list列表追加元素")
list_demo.append("e")
print(list_demo)
print("extend:批量追加")
list_demo.extend(["A","B","C"])
print(list_demo)
print("insert:在指定索引位置插入值")
list_demo.insert(1,"AAA")
print(list_demo)
print("remove:根据值移除列表里面的值,list里面没有这个值会报错")
list_demo.remove("AAA")
print(list_demo)
print("pop:根据索引删除某个值")
list_demo.pop(0)
print(list_demo)
print("index:根据值获取索引")
print(list_demo.index('A'))
print("sort:字符串排序")
list_demo.sort()
print(list_demo)
print("reverse:反转列表")
list_demo.reverse()
print(list_demo)
print("clear:清空list")
list_demo.clear()
print(list_demo)

结果：

list_demo的数据类型:<class 'list'>
['a', 'b', 'c', 'd']
append:给list列表追加元素
['a', 'b', 'c', 'd', 'e']
extend:批量追加
['a', 'b', 'c', 'd', 'e', 'A', 'B', 'C']
insert:在指定索引位置插入值
['a', 'AAA', 'b', 'c', 'd', 'e', 'A', 'B', 'C']
remove:根据值移除列表里面的值,list里面没有这个值会报错
['a', 'b', 'c', 'd', 'e', 'A', 'B', 'C']
pop:根据索引删除某个值
['b', 'c', 'd', 'e', 'A', 'B', 'C']
index:根据值获取索引
4
sort:字符串排序
['A', 'B', 'C', 'b', 'c', 'd', 'e']
reverse:反转列表
['e', 'd', 'c', 'b', 'C', 'B', 'A']
clear:清空list
[]

2.3 元组(tuple)

• 元组是一个有序不可变的容器，在里面可一个放置多个不同类型的元素

代码案例:

t1 = ("1","2",3,4,5,6)
t2 = (2)
t3 = 1
t4 = (2,)
print(t1)
print("t1的数据类型:{}".format(type(t1)))
print(t2)
print("(2)的数据类型:{}".format(type(t2)))
print(t3)
print("1的数据类型:{}".format(type(t3)))
print(t4)
print("(2,)的数据类型:{}".format(type(t4)))
list1 = [12,3,35]
print("只有字符串和列表转换为元组")
list1_tuple = tuple(list1)
print("list1的数据类型:{}".format(type(list1)))
print(list1)
print("list1_tuple的数据类型:{}".format(type(list1_tuple)))
print(list1_tuple)

结果:

('1', '2', 3, 4, 5, 6)
t1的数据类型:<class 'tuple'>
2
(2)的数据类型:<class 'int'>
1
1的数据类型:<class 'int'>
(2,)
(2,)的数据类型:<class 'tuple'>
只有字符串和列表转换为元组
list1的数据类型:<class 'list'>
[12, 3, 35]
list1_tuple的数据类型:<class 'tuple'>
(12, 3, 35)

2.4 集合(set)

• 集合是一个无序、可变、不允许数据重复的容器
• 其他数据类型可以转换为集合，如果数据重复自动删除

示例代码:

valueSet = {1,2,4,"heh"}
print("valueSet的数据类型为:{}".format(type(valueSet)))
print(valueSet)
print("add:添加元素")
valueSet.add("AAA")
valueSet.add("AAA")
print(valueSet)
print("discard:删除一个元素")
valueSet.discard(1)
print(valueSet)
valueSet2 = {"AAA",4}
print("intersection或者& 取两个集合的交集")
valueSet3 = valueSet2.intersection(valueSet)
valueSet4 = valueSet2 & valueSet
print(valueSet3)
print(valueSet4)
print("union或者|:取两个集合的并集")
valueSet5 = valueSet | valueSet2
valueSet6 = valueSet.union(valueSet2)
print(valueSet5)
print(valueSet6)
print("-或者difference:取两个集合的差集")
valueSet7 = valueSet - valueSet2
valueSet8 = valueSet.difference(valueSet2)
print(valueSet7)
print(valueSet8)

结果:

valueSet的数据类型为:<class 'set'>
{1, 2, 4, 'heh'}
add:添加元素
{1, 2, 4, 'heh', 'AAA'}
discard:删除一个元素
{2, 4, 'heh', 'AAA'}
intersection或者& 取两个集合的交集
{4, 'AAA'}
{4, 'AAA'}
union或者|:取两个集合的并集
{2, 4, 'AAA', 'heh'}
{2, 4, 'AAA', 'heh'}
-或者difference:取两个集合的差集
{2, 'heh'}
{2, 'heh'}

2.5 字典{dict}

• 字典是无序、键不重复且元素只能是键值对的可变的个容器
• python3.6之前是无序，之后是有序的

value_dict = {
    "name":"sumingyang",
    "age":18
}
value2_dict = {}
print("value_dict的数据类型为:{}".format(type(value_dict)))
print(value_dict)
print(value2_dict)
print("get:根据字典的key取对应的value")
print(value_dict.get("name"))
print("keys:去字典所有的key")
print(value_dict.keys())
print("values:取字典所有的值")
print(value_dict.values())
print("setdefault:设置字典的值")
value_dict.setdefault("address","aaaa")
print(value_dict)
print("update:修改或更新值")
value_dict.update({"age":20,"爱好":"运动"})
print(value_dict)
print("pop:移除指定键值对")
value_dict.pop("age")
print(value_dict)
print("popitem:按照顺序移除，后进先出")
value_dict.popitem()
print(value_dict)

结果:

value_dict的数据类型为:<class 'dict'>
{'name': 'sumingyang', 'age': 18}
{}
get:根据字典的key取对应的value
sumingyang
keys:去字典所有的key
dict_keys(['name', 'age'])
values:取字典所有的值
dict_values(['sumingyang', 18])
setdefault:设置字典的值
{'name': 'sumingyang', 'age': 18, 'address': 'aaaa'}
update:修改或更新值
{'name': 'sumingyang', 'age': 20, 'address': 'aaaa', '爱好': '运动'}
pop:移除指定键值对
{'name': 'sumingyang', 'address': 'aaaa', '爱好': '运动'}
popitem:按照顺序移除，先进先出
{'name': 'sumingyang', 'address': 'aaaa'}

2.6 浮点型（float）

• 浮点型，表示小数

import decimal

value_float = 3.1415926
print("value_float的数据类型为:{}".format(type(value_float)))
print(value_float)
print("浮点型转换成整形时，自动去除小数点")
value_float_int = int(value_float)
print(value_float_int)
print("decimal:精确小数计算")
v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
print(v1+v2)

结果:

value_float的数据类型为:<class 'float'>
3.1415926
浮点型转换成整形时，自动去除小数点
3
decimal:精确小数计算
0.3
0.5
0.5

2.7 代码规范

• 文件夹、文件:小写&小写下划线连接例如：commands,data_utils等
• 变量
  • 全局变量:大写&大写下划线 例如:NAME = “”、BASE_NAME=""
  • 局部变量:小写&小写下划线 例如:name= “”、base_name =""

3、进阶篇

3.1文件操作

3.1.1 读取文件

代码实例:

'''
1、打开文件
    路径：
        1、相对路径
        2、绝对路径
    模式:
        rb:表示读取文件原始的二进制（r:读取，b:二进制）
'''
# 打开文件
file_object = open("hello_word.txt", mode='rb')
# 使用绝对路径对反斜杠进行转义
file_object1 = open("C:\\Users\\smy\\PycharmProjects\\demo\\hello_word.txt", mode='rb')
print(file_object1.read())
# 读取文件
data = file_object.read()
# 关闭文件
file_object.close()
print(type(data))
print(data)
print("decode:由字节转换为str类型,使用UTF-8的字符编码")
text = data.decode("utf-8")
print(type(text))
print(text)

结果：

b'hello word'
<class 'bytes'>
b'hello word'
decode:由字节转换为str类型,使用UTF-8的字符编码
<class 'str'>
hello word

3.1.2 写入文件

• w：当文件不存在时，w模式会新建在写入内容，存在时会清空文件在写入内容

代码实例:

'''
1、打开文件
    路径：
        1、相对路径
        2、绝对路径
    模式:
        wb:表示读取文件原始的二进制（w:写入，b:二进制,t:文本类型文件）
'''
# 打开文件
file_object = open("hello_word.txt", mode='wb')
# 需要将字符串转换为字节数据
file_object.write("我正在写入数据".encode("UTF-8"))
# 关闭文件
file_object.close()
# 打开测试
file_object_read = open("hello_word.txt", mode='rb')
print(file_object_read.read().decode("utf-8"))
file_object_read.close()

结果:

我正在写入数据

模式	说明
b	字节类型数据
t	文本类型数据
r	只读，文件不存在则报错
w	只写，当文件存在则清空在写入，不存在则创建在写入
x	只写，如果文件存在则报错，不存在则创建写入
a	存在则尾部追加，不存在则创建在写入
r+,rb	读写,默认光标位置：起始位置
w+，wb+	读写,默认光标位置:起始位置（清空文件）
x+,xb+	读写,默认光标位置:起始位置（新文件）
a+,ab+	读写,默认光标位置:末尾

3.1.3 文件操作常用功能

实例代码1:

# 打开文件
file_object = open("hello_word.txt", mode='r')
print("读取第n个字符")
print(file_object.read(1))
file_object.close()

结果:

读取第n个字符
h

实例代码二:

# 打开文件
file_object = open("hello_word.txt", mode='r')
print("readline:读取一行")
print(file_object.readline())
# 关闭文件
file_object.close()

结果:

readline:读取一行
hello word1

实例代码3:

# 打开文件
file_object = open("hello_word.txt", mode='r')
print("readlines:读取所有行")
print(file_object.readlines())
# 关闭文件
file_object.close()

结果:

readlines:读取所有行
['hello word1\n', 'hello word2\n']

3.1.4 with方法使用

• 自动关闭文件

代码实例:

with open("hello_word.txt", mode='r') as file_object:
    data = file_object.read()
print(data)

结果:

hello word1
hello word2

3.1.5 csv格式文件

• 逗号分隔值,其文件以纯文本形式存储表格数据

代码实例:

with open("demo.csv",mode='r',encoding="utf-8") as file_object:
    file_object.readline()
    for line in file_object:
        print(line)
        name,age,address = line.strip().split(",")
        print(name,age)
print("监测目录是否存在")
if not os.path.exists('name'):
    # 创建name目录
    os.mkdir("name")

结果:

ming,18,hangzhou

ming 18
hai,17,shanghai

hai 17
li,26,guiyang

li 26
zhang,36,beijing

zhang 36

3.2 函数（def）

• 函数式编程
• ****只能放在*后面
• 参数和动态参数混合时。动态参数只能放最后
• 默认值参数和动态参数同时存在
• return让函数终止运行返回结果

代码示例一

 def sum(a, b):
    result = a + b
    return result
print(sum(3,23))

结果:

26

示例代码二

'''
*:元组类型传参
**:字典类型传参
'''
def sum(*args):
    print(*args)
sum(1,2,3,4,5)
def sum2(**kwargs):
    print(kwargs)
sum2(a=2,b=3)
def sum3(*args,**kwargs):
    print(args,kwargs)
sum3(1,2,3,4,a=2,b=3)

结果:

1 2 3 4 5
{'a': 2, 'b': 3}
(1, 2, 3, 4) {'a': 2, 'b': 3}

3.3 装饰器

• @函数名

  示例代码一:

  
  def a_new_decorator(a_func):
      def wrapTheFunction():
          print("I am doing some boring work before executing a_func()")
  
          a_func()
  
          print("I am doing some boring work after executing a_func()")
  
      return wrapTheFunction
  
  
  def a_function_requiring_decoration():
      print("I am the function which needs some decoration to remove my foul smell")
  
  
  a_function_requiring_decoration()
  print("".center(21,"="))
  a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
  a_function_requiring_decoration()
  

  结果:

  I am the function which needs some decoration to remove my foul smell
  =====================
  I am doing some boring work before executing a_func()
  I am the function which needs some decoration to remove my foul smell
  I am doing some boring work after executing a_func()
  

  示例代码二

  def a_new_decorator(a_func):
      def wrapTheFunction():
          print("I am doing some boring work before executing a_func()")
  
          a_func()
  
          print("I am doing some boring work after executing a_func()")
  
      return wrapTheFunction
  @a_new_decorator
  def a_function_requiring_decoration():
      print("I am the function which needs some decoration to remove my foul smell")
  
  
  a_function_requiring_decoration()
  

  结果:

  I am doing some boring work before executing a_func()
  I am the function which needs some decoration to remove my foul smell
  I am doing some boring work after executing a_func()
  

3.4 匿名函数

• 匿名函数，基于lambda表达式实现定义一个可以没有名称的函数

示例代码:

data_list = [ lambda x:x+12,lambda x:1+x,100]
print(data_list)
print(data_list[0])
print(data_list[1])
f1 = lambda x:1+233
print(f1(23))

结果:

[<function <lambda> at 0x000001EBDE7E51F0>, <function <lambda> at 0x000001EBDEA3DAF0>, 100]
<function <lambda> at 0x000001EBDE7E51F0>
<function <lambda> at 0x000001EBDEA3DAF0>
234

3.5 三元运算

示例代码:

a = 100
b = 200 if a > 19 else 100
print(b)
func = lambda x: "大" if x > 66 else "小"
print(func(a))

结果:

200
大

3.6 生成器(yield)

• 生成器函数，函数中有yield关键字
• 生成器对象，执行生成函数时会返回一个生成器对象

示例代码:

def func():
    print("这是生成器函数1")
    yield 1
    print("这是生成器函数2")
    yield 2
    print("这是生成器函数3")
    yield 3
    print("这是生成器函数4")
    yield 4
print(func())

# 在next对象放生成器对象，进入生成器函数并执行其中的代码
v1 = func()
print(next(v1))
# 在next对象放生成器对象，进入生成器函数并执行其中的代码,从上次yield返回的位置继续向下
print(next(v1))
print("使用循环遍历的方式".center(21,"="))
for i in v1:
    print(i)

结果:

<generator object func at 0x000001AE35366A50>
这是生成器函数1
1
这是生成器函数2
2
======使用循环遍历的方式======
这是生成器函数3
3
这是生成器函数4
4