1.基础知识
1 编写和运行Python程序主要有两种方式：
1 交互方式。
2 文件方式。
2 标识符
标识符就是变量、函数、属性、类、模块等可以由程序员指定名称 的代码元素。 构成标识符的字符均遵循一定的命名规则。
Python中标识符的命名规则如下。
1 区分大小写：Myname与myname是两个不同的标识符。
2 首字符可以是下画线（_）或字母，但不能是数字，如2mail
3 除首字符外的其他字符必须是下画线、字母和数字。
4 关键字不能作为标识符。
5 不要使用Python的内置函数作为自己的标识符。
3 关键字
关键字是由语言本身定义好的有特殊含义的代码元素。
and 用于表达式运算，表示逻辑与操作
as 用于类型转换
assert 断言，用于判断变量或条件表达式的值是否为真
break 中断循环语句的执行
class 用于定义类
continue 继续执行下一次循环
def 用于定义函数或方法
del 删除变量或者序列的值
elif 条件语句，与 if else 结合使用
else 条件语句，与if 和 elif 结合使用。也用于异常和循环
except 用于捕获异常后的操作代码，与try 和finally 结合使用
for 循环语句
finally 用于异常语句，出现异常后，始终要执行 finally 包含的代码块。与 try， except结合使用
from 用于导入模块，与 import结合使用
global 定义全局变量
if 条件语句，与 else ，elif 结合使用
import 用于导入模块，与from 结合使用
in 判断变量是否存在序列中
is 判断变量是否为某个类的实例
lambda 定义匿名函数
nonlocal 用于标识外部作用域的变量
not 用于表达式运算，表示逻辑非操作
or 用于表达式运算，表示逻辑或操作
pass 空的类， 函数 ，方法的占位符
print 输出语句
raise 异常抛出操作
return 用于从函数返回计算结果
try 包含可能会出现异常的语句， 与 except， finally 结合使用
while 循环语句
with 简化Python的语句
yield 用于从函数依次返回值
4 变量
在Python中为一个变量赋值的同时就声明了该变量，该变量的数据 类型就是赋值数据所属的类型，该变量还可以接收其他类型的数据。
>>> print('hello')
hello
>>> greeting="helloworld"
>>> greeting = "helloworld"
>>> greeting
'helloworld'
>>> student_score = 0.0
>>> student_score
0.0
>>> y=20
>>> y
20
>>> y=true
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
y=true
NameError: name 'true' is not defined
>>> y = True
>>> y
True
# 同时赋值多个变量
>>> a = (1 ,2 ,3)
>>> x,y,z=a
>>> print("x: %d,y :%d,z :%d"%(x,y,z))
x: 1,y :2,z :3
5 语句
Python代码是由关键字、标识符、表达式和语句等构成的，语句是 代码的重要组成部分。 在Python中，一行代码表示一条语句，在一般情况下语句结束时不 加分号。
6 模块
在Python中一个模块就是一个文件，模块是保存代码的最小单位， 在模块中可以声明变量、函数、属性和类等Python代码元素。
想模块导入所有内容用：
import＜模块名＞：通过这种方式会导入m2模块的所有代码元素，在访问时需要加前缀“m2.”
只导入模块一个元素用：
from＜模块名＞import＜代码元素＞：通过这种方式会导入m2中 的x变量，在访问时不需要加前缀“m2.”
如果名称有冲突用：
from＜模块名＞import＜代码元素＞as＜代码元素别名＞：与② 类似，在当前m1模块的代码元素（x变量）与要导入的m2模块的代码元 素（x变量）名称有冲突时，可以给要导入的代码元素（m2中的x）一 个别名x2
动动手——实现两个模块间的代码元素访问
（1）在同一文件夹下创建两个模块hello和world，即两个代码文件：hello.py和world.py。
（2）world模块的代码如下：
# codeing=utf-8 # x = '你好' y = True z = 20.0
（3）hello模块的代码如下：
# codeing=utf-8 # import world # 导入world模块中的所有代码元素 from world import z # 导入world模块中的变量z from world import x as x2 # 导入world模块中的变量x，并给它别名x2 x = 100 y = 20 print(y) # 访问当前模块变量 print(world.y) # 访问world模块变量 print(z) # 访问world模块变量z print(x2) # x2是world模块x别名
（4）运行结果：
20 True 20.0 你好
2 数据类型的数据
在Python中所有的数据类型都是类，每个数据值都是类的“实例”。 在Python中有6种主要的内置数据类型：数字、字符串、列表、元
组、集合和字典。列表、元组、集合和字典可以容纳多项数据，在本书 中把它们统称为容器类型的数据。 Python中的数字类型有4种：
整数类型、浮点类型、复数类型和布 尔类型。需要注意的是，布尔类型也是数字类型，它事实上是整数类型 的一种。
1 Python中的数据类型
在Python语言中，变量就是变量，它没有类型，我们所说的“类型”是变量值的内存中对象的类型。Python中最基本的数据类型如下所示：
Number 数字
String 字符串
List 列表
Tuple 元组
Dictionary 字典
2 字符串
1 访问字符串中的值
在Python程序中，字符串还可以通过序号（序号从0开始）来取出其中的某个字符，例如'abcd'[1] 取得的值是b。
在现实应用中还可以通过字符串的 str[beg:], str[:end], str[beg:end], 以及 str[:-index]方法来实现截取操作。
# coding = utf - 8 str = '0123456789' print(str[0:3]) # 截取第一位到第三位的字符 print(str[:]) # 截取字符串的全部字符 print(str[6:]) # 截取第七个字符到结尾 print(str[:-3]) # 截取从头开始到倒数第三个字符之前 print(str[2]) # 截取第三个字符 print(str[-1]) # 截取倒数第一个字符 print(str[::-1]) # 创造一个与原字符串顺序相反的字符串 print(str[-3:-1]) # 截取倒数第三位与倒数第一位之前的字符 print(str[-3:]) # 截取倒数第三位到结尾
运行结果
012 0123456789 6789 0123456 2 9 9876543210 78 789
2 更新字符串
开发者可以对已存在的字符串进行修改，并赋值给另一个变量。
str = '0123456789'
print('原来是：',str)
print("更新的字符串：",str[:6] + 'abcdef')
运行结果
原来是： 0123456789
更新的字符串： 012345abcdef
3 转义字符
当需要在字符中使用特殊字符时，需要用到一反斜杠 “\” 表示的转义字符。
4 格式化字符串
在Python中字符格式化的功能与c语言中的函数sprintf 类似。
# %s是格式化字符串
# %d是格式化整数
print('运行结果：')
print("名字：%s ,\n年纪： %d" % ('西门',19) )
运行结果：
名字：西门 ,
年纪： 19
5 字符串处理函数
mystr='I Love you ! .'
# 显示原始字符串
print('source string is :' ,mystr)
# 大小写字母转换
print('swapcase demo\t' ,mystr.swapcase())
# 全部转换为大写
print('upper demo\t', mystr.upper())
# 全部转换为小写
print('lower demo\t' ,mystr.lower())
# 将字符串中的单词首字母大写
print('title demo\t', mystr.title())
# 检测是否为首字母大写
print('istitle demo\t' ,mystr.istitle())
# 检测字符串是否均为小写字母
print('islower demo\t', mystr.islower())
# 将字符串的第一个字母大写
print('capitalize demo\t', mystr.capitalize())
# 获得字符串中字符“u”的起始位置
print('find demo\t', mystr.find('u'))
# 获得字符串中字符“a”的数目
print('count demo\t', mystr.count('a'))
# 分割字符串，以空格为界
print('split demo\t', mystr.split(' '))
# 连接字符串
print('join demo\t', ' '.join('abcde'))
# 获取字符串长度
print('len demo\t', len(mystr))
输出结果为：
source string is : I Love you ! .
swapcase demo i lOVE YOU ! .
upper demo I LOVE YOU ! .
lower demo i love you ! .
title demo I Love You ! .
istitle demo False
islower demo False
capitalize demo I love you ! .
find demo 9
count demo 0
split demo ['I', 'Love', 'you', '!', '.']
join demo a b c d e
len demo 14
3 数字类型
在Python程序中，数字类型Number 用于存储数值。数据类型是不允许改变的，这意味着如果改变Number 数据类型的值，将重新分配内存空间。从Python 3 开始，只支持int ，float ， bool ，complex （复数）共计4种数字类型，删除了Python 2 中long（长整数）类型。
1 整数
整型（int）就是整数，包括正整数，负整数和零，不带小数点。在Python语言中，整数的取值范围很大的，Python中的整数还可以以几种不同的进制进行书写。0 + “进制标志” + 数字 代表不同的进制的数。
现实中有如下4种常用的进制标志。
0o[0O]数字：表示八进制整数， 例如，0o24 , 0O24
0x[0X]数字： 表示十六进制整数， 例如， 0x3F, 0X3F
0b[0B]数字：表示二进制整数， 例如， 0b101 , 0B101
不带进制标志：表示十进制整数
2 浮点型
浮点型（float）有整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2=2.5X10X10=250）。
3 布尔型
布尔型是一种表示逻辑值的简单类型，它的值只能是真或假这俩个值中的一个。
4 复数型
复数型即complex 型，有实数部分和虚数部分构成，可以用a + bj或者complex(a,b)表示，复数的实部 a 和虚部 b 都是浮点型。
4 示例
1 输入年月日，判断这一天是这一年的第几天
# 函数 range()的语法格式如下：
# range(stop)
# range(start,stop[, step])
# start: 计数从start开始。默认从0开始。例如range(5) 等价于 range(0,5)
# end: 计数到end结束，但不包括 end 。例如range(0,5) 是[0,1,2,3,4]没有5
# step: 步长，默认为1。例如：range（0，5）等价于range(0,5,1)。
# 函数range()的功能是创建一个整数列表，一般被用作for循环中。
date = input("输入年月日(yyyy-mm-dd):")
y,m,d = (int(i) for i in date.split('-')) # 分割输入的数据，分别赋值给y，m，d
sum=0
special = (1,3,5,7,8,10) # 天数为31天的特殊月份
for i in range(1,int(m)):
if i == 2: # 如果是二月份
if y%400==0 or (y%100!=0 and y%4==0): # 判断是否为闰年
sum+=29 # 闰年二月有29天
else:
sum+=28 # 平年二月有28天
elif(i in special): # 判断是否为月份天数为31天的特殊月份
sum+=31
else:
sum+=30 # 月份为30天的月份
sum+=d
print("这一天是一年中的第%d天"%sum)
2 输入3个整数 x , y , z ,把3个数由小到大输出。
# 示例代码
# !/usr/bin/env python
# coding:utf-8
# 输入三个整数x,y,z，请把这三个数由小到大输出。
while 1:
try:
x = int(input("plz input x: "))
y = int(input("plz input y: "))
z = int(input("plz input z: "))
list1 = [x, y, z]
print(sorted(list1))
break
except:
print("请输入整数")
自己改编代码
x = int(input("plz input x: "))
y = int(input("plz input y: "))
z = int(input("plz input z: "))
list1 = [x, y, z]
print(sorted(list1))
# 同时输入多个值
# 1. 同时输入多个字符串,字符串间以逗号/空格间隔
#此时a,b为str型
a,b,c=input('三个字符串:').split(',')
a,b,c=input('三个字符串:').split()
#2. 同时输入多个数值,字符串间以逗号/空格间隔
#此时a,b为int型
a,b =map(int,input('输入a,b空格隔开:').split())
#此时a,b为int型
3 输出九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print("""%d*%d=%d""" % (i,j,i*j),end=" ") # end=''不换行
print()
3 运算符
1 算术运算符
算术运算符用于组织整数类型和浮点类型的数据，有一元运算符和 二元运算符之分。一元算术运算符有两个：+（正号）和-（负号），例如：+a还是a ，-a是对a的取反运算。
二元算术运算符如右表所示。
>>> a = 1 >>> a 1 >>> -a -1 >>> 1+1 2 >>> 2-1 1 >>> 2*3 6 >>> 3/2 1.5 >>> 3%2 1 >>> 3//2 1 >>> -3//2 -2 >>> 10*2 20 >>> 10.2+10 20.2 >>> 1.0 + True + 1 3.0 >>>
2 比较运算符
比较运算符用于比较两个表达式的大小，其结果是布尔类型的数据 ，即True或False。
>>> a = 1 >>> b =2 >>> a > b False >>> a < b True >>> a <= b True >>> 1.0 == 1 True >>> 1.0 != 1 False >>>
比较运算符可用于任意类型的数据，但参与比较的俩种类型的数据要相互兼容，即能进行隐式转换。例如：整数，浮点和布尔这三种类型是相互兼容的。
>>> a = "hello" >>> b = "hello" >>> a == b True >>> a="world" >>> a>b True >>> a = [] >>> b = [2,1] >>> a>b False >>> a = ["2"] >>> a>b Traceback (most recent call last): File "<pyshell#45>", line 1, in <module> a>b TypeError: '>' not supported between instances of 'str' and 'int'
比较列表大小，即逐一比较其中元素的大小，如果俩个列表中的第一个元素不能比较出大小，则比较俩个列表中的第二个元素，直到比较有了结果才结束比较。注意，在俩个列表中元素类型要兼容。
3 逻辑运算符
逻辑运算符用于对布尔型变量进行运算，其结果也是布尔型。
>>> a = 1
>>> b = 0
>>> def f1()
SyntaxError: invalid syntax
>>> def f1():
print("--进入函数f1--")
return True
>>> (a > b) or f1()
True
>>> (a < b) or f1()
--进入函数f1--
True
>>> (a < b) and f1()
False
>>> (a > b) and f1()
--进入函数f1--
True
>>>
4 位运算符
位运算是以二进位（bit）为单位进行运算的，操作数和结果都是整 数类型的数据。
>>> a = 0b10110010 >>> b = 0b01011110 >>> a | b 254 >>> a & b 18 >>> a ^ b 236 >>> ~a -179 >>> a >> 2 44 >>> a << 2 712 >>> c = -20 >>> ~c 19 >>>
在按位取反运算中涉及原码，补码，反码运算，比较麻烦。归纳总结了一个公式：~a = (a+1)X -1
5 赋值运算符
>>> a = 1 >>> b = 2 >>> a += b >>> a 3 >>> a +=b+3 >>> a 8 >>> a -= b >>> a 6 >>> a *=b >>> a 12 >>> a /= b >>> a 6.0 >>> a %=b >>> a 0.0 >>> a = 0b10110010 >>> b = 0b01011110 >>> a |= b >>> a 254 >>> a ^= b >>> a 160 >>>
6 成员运算符
in 如果在指定的序列中找到值则返回True，否则返回 False。 x在 y序列中，如果x在y序列中则返回 True。
not in 如果在指定的序列中没有找到值则返回 True，否则返回False。 x不在y序列中，如果x不在y序列中则返回 True。
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print ("1 - 变量 a 在给定的列表中 list 中")
else:
print ("1 - 变量 a 不在给定的列表中 list 中")
if ( b not in list ):
print ("2 - 变量 b 不在给定的列表中 list 中")
else:
print ("2 - 变量 b 在给定的列表中 list 中")
# 修改变量 a 的值
a = 2
if ( a in list ):
print ("3 - 变量 a 在给定的列表中 list 中")
else:
print ("3 - 变量 a 不在给定的列表中 list 中")
运行结果
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
7 身份运算符
Python语言中的身份运算符有两个，分别是is和is not。要想理解身份运算符的实现原理，需要从Python变量的属性谈起。Python语言中的变量有3个属性，分别是name、id和value，具体说明如下所示。 name 可以理解为变量名 id 可以联合内存地址来理解， value 就是变量的值。
在Python语言中，身份运算符 “is” 通过这个 id 来进行判断。如果 id 一样返回True，否则，返回False
a = [1,2,3]
b = [1,2,3]
print("运行结果：")
print(a==b)
print(a is b)
运行结果：
True
False
身份运算符具体使用过程
a = 20
b = 20
if ( a is b ):
print ("1 - a 和 b 有相同的标识")
else:
print ("1 - a 和 b 没有相同的标识")
if ( id(a) == id(b) ):
print ("2 - a 和 b 有相同的标识")
else:
print ("2 - a 和 b 没有相同的标识")
# 修改变量 b 的值
b = 30
if ( a is b ):
print ("3 - a 和 b 有相同的标识")
else:
print ("3 - a 和 b 没有相同的标识")
if ( a is not b ):
print ("4 - a 和 b 没有相同的标识")
else:
print ("4 - a 和 b 有相同的标识")
运行结果：
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
8 运算符的优先级
>>> 1 - 2 * 2 -3 >>> a = 0b10110010 >>> b = 0b01011110 >>> c = 0b11 >>> a | b & c 178 >>> b & c 2 >>> a | 2 178 >>> a | b 254 >>> 254 & c 2 >>>
# coding=utf-8 # 优先级的简单实例 priorityNumber=2+1*4 print (priorityNumber) # 输出结果：6 # 优先级使用实例 # 以下优先级排名从高到低，在同一运算中，先执行优先级高的再执行低的，以此类推。 # Top 1:函数调用、寻址、下标 # Top 2:幂运算** priorityNumber = 2*2**3 print(priorityNumber) # 输出结果：16 # Top 3:翻转运算~ # Top 4:正负号 print(1+2*-3) # 输出结果：-5 # Top 5:*、/、% print(2+1*2/5) # 输出结果：2 # Top 6:+、- print(3 << 2+1) # 输出结果：24 # Top 7:<<、>> # Top 8:按位&、^、| # Top 9:比较运算符 priority = 2*3+2 <= 2+1*7 print(priority) # 输出结果：True # Top 10:逻辑的not and or # Top 11:lambda表达式 # python优先级使用规律 # 1、一般情况下是左结合的 # ps:在没有更高优先级运算符，即只有同级运算符时时从左到右结合 print(1+2+3*5+5) # 输出结果：23 # 2、出现赋值的时候一般是右结合 # ps:在有赋值运算符时，是右结合，即先算出1+2的值以后再赋值给priority priority = 1+2 print(priority) # 输出结果：3
位运算中的难点是位反，右移和左移，位反过程比较复杂，但可以使用归纳的公式 ~a = (a+1) x -1 推算出结果。右移时采用符号位补位，符号位为1说明是负数，用1补位；符号位为0说明是正数，用0补位。
在位运算优先级中，优先级从高到低大体是: 算术运算符->位运算符->关系运算符->逻辑运算符->赋值运算符。
9 示例
1 暂停一秒输出，并格式化当前时间。
import time # 引入time模块
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
a = 0
while a < 10: #计时十秒
a += 1
# 暂停一秒
time.sleep(1)
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
2 古典问题：一对小兔子，从出生三个月起每月都生一对小兔子，小兔子长到第三个月又生一对小兔子，假如兔子都不死，每个月的兔子总数是多少？
# -*- coding: UTF-8 -*-
"""""
第一个月、第二个月小兔子没有繁殖能力，所以还是1对两个月后，生下一对小兔民数共有2对
三个月以后，老兔子又生下一对，因为小兔子还没有繁殖能力，所以一共是3对，
依次类推可以列出下表兔子的规律为数列1, 1, 2, 3, 5, 8, 13, 21....
这个数列有关十分明显的特点，那是：前面相邻两项之和，构成了后一项。
这个数列是意大利中世纪数学家斐波那契在 < 算盘全书 > 中提出的。
"""
f1 = 1
f2 = 1
for i in range(1,22):
print('%12ld %12ld' % (f1,f2))
# %12ld 的意思就是输入一个12位的整数 在python 中的形式是12d 不需要加l 两个12就是两个12位的整数 没有数值就是空格。
if (i % 3) == 0:
print('')
f1 = f1 + f2
f2 = f1 + f2
运行结果
1 1
2 3
5 8
13 21
34 55
89 144
233 377
610 987
1597 2584
4181 6765
10946 17711
28657 46368
75025 121393
196418 317811
514229 832040
1346269 2178309
3524578 5702887
9227465 14930352
24157817 39088169
63245986 102334155
165580141 267914296
3 求101到200之间的素数
list1 = []
list2 = []
for x in range(2, 101):
for i in range(2, x+1):
sum = x * i # 2到100之间的数互相求乘积，得到的数是非素数
if (sum <= 200) & (sum >= 101): # 找出大于101小于200之间的非素数
list1.append(sum) # 使用append函数在列表追加一个元素：append函数参数为元素。
for m in range(101, 201):
list2.append(m) # 集合（set）是一个无序的不重复元素序列。
list3 = list(set(list2) ^ set(list1)) # 俩个数组异或，找出不同的数就是素数
print(list1, '\n')
print(list3)
print("总数为：", len(list3))
运行结果：
[110, 121, 108, 120, 132, 144, 104, 117, 130, 143, 156, 169, 112, 126, 140, 154, 168, 182, 196, 105, 120, 135, 150, 165, 180, 195, 112, 128, 144, 160, 176, 192, 102, 119, 136, 153, 170, 187, 108, 126, 144, 162, 180, 198, 114, 133, 152, 171, 190, 120, 140, 160, 180, 200, 105, 126, 147, 168, 189, 110, 132, 154, 176, 198, 115, 138, 161, 184, 120, 144, 168, 192, 125, 150, 175, 200, 104, 130, 156, 182, 108, 135, 162, 189, 112, 140, 168, 196, 116, 145, 174, 120, 150, 180, 124, 155, 186, 128, 160, 192, 132, 165, 198, 102, 136, 170, 105, 140, 175, 108, 144, 180, 111, 148, 185, 114, 152, 190, 117, 156, 195, 120, 160, 200, 123, 164, 126, 168, 129, 172, 132, 176, 135, 180, 138, 184, 141, 188, 144, 192, 147, 196, 150, 200, 102, 153, 104, 156, 106, 159, 108, 162, 110, 165, 112, 168, 114, 171, 116, 174, 118, 177, 120, 180, 122, 183, 124, 186, 126, 189, 128, 192, 130, 195, 132, 198, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200]
[101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199]
总数为： 21
4 程序流程控制
1 分支语句
分支语句也被称为条件语句，Java和C等很多编程语言都有判断语句if和多分支语句switch。Python的设计理念是简单，刚好够用，所以在Python中没有switch语句，多分支功能是通过if—elif—else实现的。
if语句有三种结构：
if
if—else
if—elif—else
1 if机构的语法
if 条件：
语句组
# coding = utf-8
score = int(input("请输入一个整数："))
if score >=85:
print("你真优秀")
if score <= 60:
print("你需要加倍努力")
if ( score > 60 ) and ( score < 85 ) :
print("你还需要努力")
使用 if 判断
flag = False
# name = 'luren'
name = 'python'
if name == 'python': # 判断变量否为'python'
flag = True # 条件成立时设置标志为真
print ('welcome boss') # 并输出欢迎信息
else:
print (name) # 条件不成立时输出变量名称
比较俩个变量的大小
a=2
b=8
if a<b: #python if语句条件为真True
print ('a<b') #会被执行
if a>b: #条件为假False
print ('a>b') #不会被执行
2 if-else 结构的语法
if 条件 ：
语句组1
else ：
语句组2
# clding = utf - 8
score = int(input("输入整数："))
if score >= 60:
if score >= 85 :
print("你很优秀")
else:
print("你还需要努力")
else:
print("你需加倍努力")
使用多条件判断语句
num = 5
if num == 3: # 判断num的值
print ('boss')
elif num == 2:
print ('user')
elif num == 1:
print ('worker')
elif num < 0: # 值小于零时输出
print ('error')
else:
print ('roadman') # 条件均不成立时输出
俩个判断条件的 if 语句
x = int(input("please input a integer:"))
# x = input('Please input a integer:')
# x = int(x)
if x < 0:
print('你输入了一个负数。')
elif x == 0:
print('你输入了一个零。')
else:
print('你输入了一个正数。')
3 if-elif-else 结构的语法
if 条件1 ：
语句组1
elif 条件2：
语句组2
elif 条件3：
语句组3
................
elif 条件n：
语句组n
else：
语句组n+1
# coding = utf - 8
score = int (input("输入成绩："))
if score >= 90:
grade = 'a'
elif score >= 80:
grade = 'b'
elif score >= 70:
grade = 'c'
elif score >= 60 :
grade = 'd'
else:
grade = 'e'
print("Grade =" + grade)
# print(grade)
使用 else 语句进行指定
age = 17
if age >= 18:
print("You are old enough to vote!")
print("Have you registered to vote yet?")
else:
print("Sorry, you are too young to vote.")
print("Please register to vote as soon as you turn 18!")
门票销售系统
# age = 12
age = int(input("年纪："))
if age < 4:
price = 0
elif age < 18:
price = 5
elif age < 65:
price = 10
elif age >= 65:
price = 5
print("Your admission cost is $" + str(price) + ".")
print("Your admission cost is $ %d" % price)
使用俩层嵌套
requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
if 'mushrooms' in requested_toppings:
print("Adding mushrooms")
elif 'french fries' in requested_toppings:
print("Adding french fries")
elif 'extra cheese' in requested_toppings:
print("Adding extra cheese")
print("\nFinished making your pizza!")
4 switch功能实现
switch 语句是为了判断多条件诞生的。使用 switch 语句的方法和使用 if 嵌套语句的方法十分相似，但是 switch 语句更加直观，更加容易理解。例如在 Java 语言中，使用 switch 语句后可以对条件进行多次判断。
switch() {
case 整数值1 : 语句; break;
case 整数值2 : 语句; break;
case 整数值3 : 语句; break;
case 整数值4 : 语句; break;
case 整数值5 : 语句; break;
// ..
default : 语句；
}
但是在Python中没有提供 switch 功能，只能通过其他方式来实现switch功能。
1 使用elif实现
简单的语句组
# -*- coding: UTF-8 -*-
var = 100
if var == 100:
print("变量 var 的值为100" )
print("Good bye!")
成绩考核系统
score = input("score:")
score=int(score)
if(score >= 90) and (score <= 100):
print ("A")
elif(score >= 80) and (score < 90):
print ("B")
elif(score >= 60) and (score < 80):
print ("C")
else:
print ("D")
2 使用字典实现
检查列表中的特殊元素
requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
for requested_topping in requested_toppings:
if requested_topping == 'french fries':
print("Adding " + requested_topping + ".")
else:
print("Sorry, we don't have " + requested_topping + ".")
print("\nFinished making your pizza!")
使用多个列表
available_toppings = ['mushrooms', 'olives', 'green peppers',
'pepperoni', 'pineapple', 'extra cheese']
requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
for requested_topping in requested_toppings:
if requested_topping in available_toppings:
print("Adding " + requested_topping + ".")
else:
print("Sorry, we don't have " + requested_topping + ".")
print("\nFinished making your pizza!")
3 自定义编写一个类实现
定义一个私有类
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
#在python中也有私有属性定义，使用函数名前缀的两个下划线进行定义。
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s is speaking: I am %d years old" %(self.name,self.age))
p = people('tom',10,30)
p.speak()
定义一个继承类
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s is speaking: I am %d years old" %(self.name,self.age))
p = people('tom',10,30)
p.speak()
#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w) #
self.grade = g
#覆写父类的方法
def speak(self):
print("%s is speaking: I am %d years old,and I am in grade %d"%(self.name,self.age,self.grade))
s = student('ken',20,60,3)
s.speak()
在python2 中导入未来的支持的语言特征中division(精确除法)，即from future import division ，当我们在程序中没有导入该特征时，"/"操作符执行的只能是整除，也就是取整数，只有当我们导入division(精确算法)以后，"/"执行的才是精确算法。
#python 2.7.6 Python ` `2.7` `.` `6` `(default, Nov ` `10` `2013` `, ` `19` `:` `24` `:` `18` `) [MSC v.` `1500` `32` `bit (Intel)] on win32 Type` `"copyright"` `, ` `"credits"` `or` `"license()"` `for` `more information. #导入前 >>> ` `1` `/` `2 0 >>> ` `10` `/` `3 3 #导入后 >>> ` `from` `__future__ ` `import` `division >>> ` `1` `/` `2 0.5 >>> ` `10` `/` `3 3.3333333333333335 #导入后如果要去整数，加'//' >>> ` `10` `/` `/` `3 3
但是在python3中已经支持了精确算法，所以无需再导入division(精确算法)：
#python3.4.4 Python ` `3.4` `.` `4` `(v3.` `4.4` `:` `737efcadf5a6` `, Dec ` `20` `2015` `, ` `20` `:` `20` `:` `57` `) [MSC v.`1600`64` `bit (AMD64)] on win32 Type` "copyright", "credits"` `or` `"license()"` `for` `more information. >>>1/2 0.5 >>> 10/3 3.3333333333333335 #如果需要取整数，加'//' >>> 10//3 3
5 示例
1 输出所有水仙花数。
for n in range(100,1000):
m = n
sumValue = 0
while(m>0):
(m,r) = divmod(m, 10)
# python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
sumValue += r ** 3
if n == sumValue:
print(n)
2 对于一个正整数分解质因数
def prime(n):
l = []
while n > 1:
for i in range(2, n + 1):
if n % i == 0:
n = int(n / i)
l.append(i)
break
return l
s = input("输入一个正整数:")
if s.isdigit() and int(s) > 0: # Python isdigit() 方法检测字符串是否只由数字组成
print(s, "=", "*".join([str(x) for x in prime(int(s))]))
else:
print("请输入正确的正整数")
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );
运行结果：
a-b-c
3 输出第十个斐波那契数列
# def fib(n): n = 10 a, b = 1, 1 for i in range(n - 1): a, b = b, a + b print(a) # return a 运行结果 1 2 3 5 8 13 21 34 55
# -*- coding: UTF-8 -*-
def fib(n):
a,b = 1,1
for i in range(n-1):
a,b = b,a+b
return a
# 输出了第10个斐波那契数列
print (fib(10))
运行结果
55
4 条件运算符的嵌套，成绩系统
i = int(input('请输入成绩：'))
ar = [90,60,0]
res = ['A','B','C']
for idx in range(0, 3):
if i >= ar[idx]:
print(res[idx])
break
2 循环语句
Python支持两种循环语句：while和for。
1 while 语句
在Python中只有while 语句，没有 do-while 语句。while 语句先判断循环条件，若条件位True 则执行循环体。
while 循环条件 ：
循环体语句组
[else:
语句组]
# coding = utf - 8
i = 0
while i*i < 1000 :
i += 1
print("i = " + str(i))
print("i*i= " + str(i*i))
运行结果：
D:\Python\python.exe D:/Python/pythonProject/while.py i = 32 i*i= 1024 Process finished with exit code 0
在Python中while语句中还可以有带有else语句，else语句是在循环体正常结束时才执行的语句，当循环被中断时不执行，当遇到break，return 和有异常发生时会中断。
# coding=utf-8
a = 0
while a*a < 10 :
a += 1
print(str(a) + '*' + str(a) + '=' ,a * a )
else :
print('while over')
运行结果
1*1= 1 2*2= 4 3*3= 9 4*4= 16 while over
-
使用break 语句
break 语句的功能是终止循环语句，即使循环语句没有False 条件或者序列没有完全递归完，也会停止执行循环语句。break常用于while 循环语句 和 for 循环语句。
修改示例代码，添加判断：
# coding=utf-8
a = 0
while a*a < 10 :
a += 1
if a == 3 :
break
print(str(a) + '*' + str(a) + '=' ,a * a)
else :
print('while over')
运行结果
1*1= 1 2*2= 4
2 使用continue 语句
continue 语句的功能是跳出本次循环。break 语句是跳出整个循环。
for letter in 'python':
if letter == 'h':
continue
print("当前字母：",letter)
var = 10
while var > 0:
var=var-1
if var ==5:
continue
print("当前变量值为",var)
print('执行完毕')
当前字母： p
当前字母： y
当前字母： t
当前字母： o
当前字母： n
当前变量值为 9
当前变量值为 8
当前变量值为 7
当前变量值为 6
当前变量值为 4
当前变量值为 3
当前变量值为 2
当前变量值为 1
当前变量值为 0
执行完毕
3 使用 pass 语句
pass 是一个空语句，视为了保持程序结构的完整性而推出的语句。在代码程序中pass不做任何事情，一般只用作占位语句。
2 for 语句
基于简单的设计理念，在Python中只有一种for语句，即for—in语句，它可以遍历任意可迭代对象中的元素。
for 变量 in 可迭代对象：
循环体语句组
[else :
语句组]
# coding = utf - 8
print('----字符串----')
for item in 'hello' :
print (item)
# 声明整数列表
number = [43,32,55,74]
print('----整数列表----')
for item in number :
print(item)
运行结果
----字符串---- h e l l o ----整数列表---- 43 32 55 74
Python中的for语句与while语句类似，其中也可以带有else子语句，else子语句的作用与在while中是一样的，在循环体正常结束时才执行else语句，在循环被中断时不执行，在遇到break，return和有异常发生时都会中断循环。
range() 语法格式：
range( [start,] stop[, step] )
start: 可选参数，起始数，默认为0
stop: 终止数 ，如果range 只有一个参数x，那么range 生产一个从0 至x-1 的整数列表。
step: 可选参数，表示步长，即每次循环序列增长值
print('第一次循环输出：')
for i in range(4):
print(i)
print('第二次循环输出：')
for i in range(0,7,2):
print(i)
第一次循环输出：
0
1
2
3
第二次循环输出：
0
2
4
6
for item in range(10) :
print (item)
else :
print('For over')
运行结果
0 1 2 3 4 5 6 7 8 9 For over
修改示例代码，增加中断：
for item in range(10) :
if item == 3:
break
print (item)
else :
print('For over')
运行结果：
0 1 2
判断是否为质数：
for num in range(10 , 20):
for i in range(2,num):
if num%i==0:
j=num/i
print("%d 等于 %d * %d"% (num,i,j))
break
else:
print(num,"是一个质数")
10 等于 2 * 5
11 是一个质数
12 等于 2 * 6
13 是一个质数
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一个质数
18 等于 2 * 9
19 是一个质数
获取俩个整数之间的素数
x = (int(input("请输入开始值（整数）：")),int(input("请输入一个结束值（整数）：")))
x1 = min(x)
x2 = max(x)
if x1 == x2:
print("请输入俩个不同的值！")
for n in range(x1,x2+1):
for i in range(2,n-1):
if n % i == 0:
break
else:
print(n, "是素数。")
3 跳转语句
跳转语句能够改变程序的执行顺序，包括break、continue和return。 break和continue用于循环体中，而return用于函数中。本节先介绍break 和continue语句，对于return语句，将在后面的章节中介绍。
1 使用break 语句
break 语句的功能是终止循环语句，即使循环语句没有False 条件或者序列没有完全递归完，也会停止执行循环语句。break常用于while 循环语句 和 for 循环语句。
修改示例代码，添加判断：
# coding=utf-8
a = 0
while a*a < 10 :
a += 1
if a == 3 :
break
print(str(a) + '*' + str(a) + '=' ,a * a )
else :
print('while over')
运行结果
1*1= 1 2*2= 4
2 使用continue 语句
continue 语句的功能是跳出本次循环。break 语句是跳出整个循环。
for letter in 'python':
if letter == 'h':
continue
print("当前字母：",letter)
var = 10
while var > 0:
var=var-1
if var ==5:
continue
print("当前变量值为",var)
print('执行完毕')
当前字母： p
当前字母： y
当前字母： t
当前字母： o
当前字母： n
当前变量值为 9
当前变量值为 8
当前变量值为 7
当前变量值为 6
当前变量值为 4
当前变量值为 3
当前变量值为 2
当前变量值为 1
当前变量值为 0
执行完毕
3 使用 pass 语句
pass 是一个空语句，视为了保持程序结构的完整性而推出的语句。在代码程序中pass不做任何事情，一般只用作占位语句。
for letter in 'python':
if letter == 'h':
pass
print("这是一个pass语句，是一个空语句，什么都不执行")
print('当前字母：',letter)
print('over')
当前字母： p
当前字母： y
当前字母： t
这是一个pass语句，是一个空语句，什么都不执行
当前字母： h
当前字母： o
当前字母： n
over
4 示例
1 输出指定格式的日期， 使用datatime 模块
import datetime
print(datetime.date.today()) # datetime.date(2017, 6, 27)
print(datetime.date.today().strftime('%d/%m/%Y')) # '27/06/2017'
print(datetime.date(1941, 1, 5)) # datetime.date(1941, 1, 5)
2021-01-11
11/01/2021
1941-01-05
Python time strftime() 函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数 format 决定。
-
format -- 格式字符串。
-
t -- 可选的参数t是一个struct_time对象。
返回以可读字符串表示的当地时间。
python中时间日期格式化符号：
-
%y 两位数的年份表示（00-99）
-
%Y 四位数的年份表示（000-9999）
-
%m 月份（01-12）
-
%d 月内中的一天（0-31）
-
%H 24小时制小时数（0-23）
-
%I 12小时制小时数（01-12）
-
%M 分钟数（00=59）
-
%S 秒（00-59）
-
%a 本地简化星期名称
-
%A 本地完整星期名称
-
%b 本地简化的月份名称
-
%B 本地完整的月份名称
-
%c 本地相应的日期表示和时间表示
-
%j 年内的一天（001-366）
-
%p 本地A.M.或P.M.的等价符
-
%U 一年中的星期数（00-53）星期天为星期的开始
-
%w 星期（0-6），星期天为星期的开始
-
%W 一年中的星期数（00-53）星期一为星期的开始
-
%x 本地相应的日期表示
-
%X 本地相应的时间表示
-
%Z 当前时区的名称
-
%% %号本身
2 输入一行字符，分别统计出其中的英文字母，空格，数字 和其他字符的个数。
a = input('请输入一串字符:')
英文 = 0
空格= 0
数字= 0
其他= 0
for i in a:
if i.isalpha():
英文 += 1
elif i.isspace():
空格 += 1
elif i.isnumeric():
数字 += 1
else:
其他 += 1
print('英文 = %s,空格 = %s,数字 = %s,其他 = %s' % (英文,空格,数字,其他))
3 求s=a+aa+aaa+aaaa+.....的值，a是一个数字。
n = int(input('n = '))
a = int(input('a = '))
sum = 0
total = 0
for i in range(n):
sum += (10 ** i)
total += sum * a
print(total)
4 一个数恰好等于它的因子之和，这个数就称为“完数”。例如6=1+2+3.
list2 = []
for x in range(1, 1001):
list1 = []
for i in range(1, int(x / 2) + 1):
if x % i == 0:
list1.append(i)
if x == sum(list1):
print(x)
print(list1)
list2.append(x)
print("共计有%d个完数"%(len(list2)))
5 使用列表
1 列表类型基础
car = ['aodi','baoma','bengchi']
for message in car :
print(message.title()+ " is my first car " )
print('i want to buy '+message.title()+'.\n')
print('all good')
2 列表的基本操作
1 更新列表元素（修改）
car = ['aodi','baoma','bengchi'] print(car) car[0] = 'dazhong' # 修改第一个 print(car) ['aodi', 'baoma', 'bengchi'] ['dazhong', 'baoma', 'bengchi']
2 插入新元素
1 在列表中插入元素 list.insert()
在Python程序中，使用方法insert()可以在列表的任何位置添加新元素，在插入时需要指定新元素的索引和值。使用方法insert()的 语法格式如下所示： list.insert(index, obj)
obj ： 将要插入的元素
index： 元素obj需要插入的索引的位置
car = ['aodi','baoma','bengchi'] print(car) car[0] = 'dazhong' print(car) car.insert(0,'kaidilake') print(car) ['aodi', 'baoma', 'bengchi'] ['dazhong', 'baoma', 'bengchi'] ['kaidilake', 'dazhong', 'baoma', 'bengchi']
2 在列表末尾插入元素 list.append(obj)（添加）
当在列表中添加新元素时，最简单的方式是将元素附加到列表末尾。在Python程序中，使用方法append()可以在列表末尾添加新的元素。使用方法append()的语法格式如下所示： list.append(obj)
car = ['aodi','baoma','bengchi']
print(car)
car[0] = 'dazhong'
print(car)
car.append('kaidilake') # 插入最后
print(car)
['aodi', 'baoma', 'bengchi']
['dazhong', 'baoma', 'bengchi']
['dazhong', 'baoma', 'bengchi', 'kaidilake']
3 在列表中删除元素
1 使用del语句删除元素
在Python程序中，如果知道要删除的元素在列表中的具体位置，可使用del语句实现删除功能。
car = ['aodi','baoma','bengchi'] print(car) del car[0] print(car) ['aodi', 'baoma', 'bengchi'] ['baoma', 'bengchi']
2使 用pop()方法删除元素
在Python程序中，当将某个元素从列表中删除后，有时需要接着使用这个元素的值。例如在Web应用程序中，将某个用户从活跃成员列表中删除后，接着可能需要将这个用户加入到非活跃成员列表中。
car = ['aodi','baoma','bengchi'] print(car) car.pop(0) print(car) ['aodi', 'baoma', 'bengchi'] ['baoma', 'bengchi']
3 显示列表中某个位置的元素
经过前面的内容可知，在Python程序中，使用方法pop()可以删除列表中任何位置的元素，这只需在括号中指定要删除的元素的索引即可实现。
car = ['aodi','baoma','bengchi']
print(car)
first_owned = car.pop(0) #
print('my first car is '+ first_owned.title())
print(car)
my first car is Aodi
['baoma', 'bengchi']
4 根据元素值删除元素 list.remove(obj)
在Python程序中，有时并不知道要从列表中删除的值所处的位置。如果只知道要删除的元素的值，可使用方法remove()实现。 list.remove(obj)
car = ['aodi','baoma','bengchi']
print(car)
too_expensive = 'aodi'
car.remove(too_expensive)
print(car)
print('\n '+too_expensive.title()+" is too expensive for me")
['aodi', 'baoma', 'bengchi']
['baoma', 'bengchi']
Aodi is too expensive for me
3 列表排列处理
1 使用方法sort()对列表进行永久性排序
在Python程序中，使用方法sort()可以轻松地对列表中的元素进行排序。方法sort()用于对原列表中的元素进行排序，使用此方法 的语法格式如下所示。 list.sort([func])
参数 func 是一个可选参数。如果指定了该参数则使用该参数的方法进行排序。虽然方法 sort() 没有返回值，但是会对列表中的元 素进行排序。
数字 从小到大
# 按字母顺序进行排序 从小到大 car = ['leikesasi','aodi','baoma','bengchi'] car.sort() print(car) ['aodi', 'baoma', 'bengchi', 'leikesasi']
还可以按照字母顺序相反的顺序排列列表元素，此时，只须向 sort() 方法传递参数 reverse = True 即可。
数字从大到小
car = ['leikesasi','aodi','baoma','bengchi'] car.sort(reverse=True) # 排列从大到小 print(car) ['leikesasi', 'bengchi', 'baoma', 'aodi']
list=[1,2,3,4,5,6,7,8,9,2,8,11,12,6,8,6,3,7,1,2,2,2,2,9,6]
duplicate_number = []
for i in list:
i_count = list.count(i) # count函数用来统计次数
if i_count > 1 and [i,i_count] not in duplicate_number: # 骚操作
duplicate_number.append([i,i_count])
print('[重复数字 重复次数]')
print(duplicate_number)
for item in duplicate_number:
duplicate_n = item[0]
duplicate_time = item[1]
for i in range(duplicate_time - 1):
list.remove(duplicate_n)
print(f'删除过程：删除了数字 {duplicate_n}，删除了{duplicate_time - 1}次 ')
print(f'结果 : {list}')
list.sort()
print(f'从小到大 ：{list}')
list.sort(reverse=True) #
print(f'从大到小 ：{list}')
[重复数字 重复次数]
[[1, 2], [2, 6], [3, 2], [6, 4], [7, 2], [8, 3], [9, 2]]
删除过程：删除了数字 1，删除了1次
删除过程：删除了数字 2，删除了5次
删除过程：删除了数字 3，删除了1次
删除过程：删除了数字 6，删除了3次
删除过程：删除了数字 7，删除了1次
删除过程：删除了数字 8，删除了2次
删除过程：删除了数字 9，删除了1次
结果 : [4, 5, 11, 12, 8, 3, 7, 1, 2, 9, 6]
从小到大 ：[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12]
从大到小 ：[12, 11, 9, 8, 7, 6, 5, 4, 3, 2, 1]
2 使用方法sorted()对列表进行临时排序
在Python程序中，要想既保留列表元素原来的排列顺序，同时又想以特定的顺序显示它们，此时可以使用方法sorted()实现。方法sorted()的功能是按照特定顺序显示列表中的元素，同时不影响它们在列表中的原始排列顺序。
car = ['leikesasi','aodi','baoma','bengchi']
print("列表中原来的显示顺序是：")
print(car)
print("\n经过排列处理后的顺序是：")
print(sorted(car))
print("\n再次显示列表中原来的排列顺序是：")
print(car)
列表中原来的显示顺序是：
['leikesasi', 'aodi', 'baoma', 'bengchi']
经过排列处理后的顺序是：
['aodi', 'baoma', 'bengchi', 'leikesasi']
再次显示列表中原来的排列顺序是：
['leikesasi', 'aodi', 'baoma', 'bengchi']
3 倒序输出列表中的信息 list.reverse()
在Python程序中，有时需要倒序打印输出列表中的信息，此时可以通过方法reverse()实现。使用方法reverse()的语法格式如下所示。 list.reverse() 方法reverse()没有参数，也没有返回值。
car = ['leikesasi','aodi','baoma','bengchi']
print("列表中原来的显示顺序是：")
print(car)
print("\n经过排列处理后的顺序是：")
car.reverse()
print(car)
print("\n再次显示列表中原来的排列顺序是：")
print(car)
列表中原来的显示顺序是：
['leikesasi', 'aodi', 'baoma', 'bengchi']
经过排列处理后的顺序是：
['bengchi', 'baoma', 'aodi', 'leikesasi']
再次显示列表中原来的排列顺序是：
['bengchi', 'baoma', 'aodi', 'leikesasi']
4 获取列表的长度 len(list)
在Python程序中，可以使用方法len()可快速获取列表的长度。使用方法len()的语法格式如下所示。 len(list) 在上述格式中，参数“list”表示要计算元素个数的列表，执行后会返回列表元素的个数。
cars = ['宝马', '奥迪', '奔驰', '雷克萨斯'] len(cars)
4 列表的高级操作
1 列表中的运算符
| Python表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] *4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 显示元素是否存在于列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
2 列表截取与拼接
L = [ 'Goole' ,'Apple' ,'Taobao']
| Python表达式 | 结果 | 描述 |
|---|---|---|
| L[2] | 'Taobao' | 读取第三个元素 |
| L[-2] | 'Apple' | 从右侧开始读取倒数第二个元素：count from the right |
| L[1:] | [' Apple ', 'Taobao'] | 输出从第二个元素开始后的所有元素 |
# 列表截取与拼接 car = ['leikesasi','aodi','baoma','bengchi'] print(car[1]) print(car[-2]) print(car[1:]) l = ['apple','banana'] print(l+['oroge','tomato']) aodi baoma ['aodi', 'baoma', 'bengchi'] ['apple', 'banana', 'oroge', 'tomato']
3 列表嵌套
在Python程序中，列表嵌套是指在一个已经存在的列表中创建其它新的列表。
a = ['a','b','c'] n = [1,2,3] x = [a,n] print(x) print(x[0]) print(x[0][1]) [['a', 'b', 'c'], [1, 2, 3]] ['a', 'b', 'c'] b
4 获取列表元素中的最大值和最小值
在Python程序中，可以通过方法max()获取列表元素中的最大值，使用方法max()的语法格式如下所示。 max(list) 其中参数“list”表示要返回最大值的列表，方法max()的返回值是返回列表元素中的最大值。 在Python程序中，可以通过方法min()获取列表元素中的最小值，使用方法min()的语法格式如下所示。 min(list) 其中参数“list”表示要返回最大值的列表，方法min()的返回值是返回列表元素中的最大值。
list1,list2 = ['Goole','Apple','Taobao'],[456,700,200]
print("list1中最大元素值：",max(list1))
print("list2中最大元素值：",max(list2))
print("list1中最小元素值：",min(list1))
print("list2中最小元素值：",min(list2))
list1中最大元素值： Taobao
list2中最大元素值： 700
list1中最小元素值： Apple
list2中最小元素值： 200
5 追加其他列表中的值 list.extend(seq)
在Python程序中，可以通过方法extend()在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。使用方法 extend()的语法格式如下所示。 list.extend(seq) 其中参数“seq”表示将要追加的列表，方法extend()没有返回值，可以在已存在的列表中添加新的列表内容。
list1,list2 = ['Goole','Apple','Taobao'],[456,700,200]
list3=list(range(5))
list1.extend(list3)
print("扩展后的列表： ", list1)
扩展后的列表： ['Goole', 'Apple', 'Taobao', 0, 1, 2, 3, 4]
6 在列表中统计某元素出现的次数 list.count(obj)
在Python程序中，可以通过方法count()在列表中统计某元素出现的次数。使用方法count()的语法格式如下所示。 list.count(obj) 其中参数“obj”表示将要统计的列表对象，方法count()的返回值是在列表中出现的次数。
7 清空列表中的元素 list.clear()
在Python程序中，可以使用方法clear()清空列表中的元素，其功能类似于“del a[:]”表达式。使用方法clear()的语法格式如下所示。 list.clear() 方法clear()没有参数也没有返回值。
8 复制列表中的元素 list.copy()
在Python程序中，可以使用方法copy()复制列表中的元素，这样可以创建一个新的列表。使用方法copy()的语法格式如下所示。 list.copy() 方法copy()没有参数，返回值是返回复制后的新列表。
9 获取列表中的某个元素的索引 list.index(obj)
在Python程序中，可以使用方法index()获取列表中的某个元素的具体索引位置，只能从列表中找出某个元素值第一次出现的索引位置。 使用方法index()的语法格式如下所示。 list.index(obj) 在上述格式中，参数“obj”表示将要查找的列表对象。方法index()的返回值是返回查找列表对象的索引位置，如果没有找到对象则抛出异常。
10 切片
list = [1,2,3,4,5,6,7,8,9] print(list[0:5]) print(list[0:]) print(list[:]) print(list[0:8:1]) print(list[0:8:2]) print(list[0::2]) print(list[::2]) 输出 [1, 2, 3, 4, 5] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8] [1, 3, 5, 7] [1, 3, 5, 7, 9] [1, 3, 5, 7, 9]
11 反转
list = [1,2,3,4,5,6,7,8,9] print(list[::-1]) print(list[9:0:-1]) print(list[0:9:-1]) print(list[9:0:1]) 9, 8, 7, 6, 5, 4, 3, 2, 1 [9, 8, 7, 6, 5, 4, 3, 2] [] []
5 示例
1 将一个列表中的数复制到另一个列表中
a = [1, 2, 3] b = a[:] print(b) [1, 2, 3]
2 一个求从100米的高度自由落下，每次落地后反跳会原高度的一半，再落下，那么在它第十次落地是，共经过多少米，第十次反弹多高
tour = []
height = []
hei = 100.0 # 起始高度
tim = 10 # 次数
for i in range(1, tim + 1):
# 从第二次开始，落地时的距离应该是反弹高度乘以2（弹到最高点再落下）
if i == 1:
tour.append(hei)
else:
tour.append(2*hei)
hei /= 2
height.append(hei)
print('总高度：tour = {0}'.format(sum(tour)))
print('第10次反弹高度：height = {0}'.format(height[-1]))
总高度：tour = 299.609375
第10次反弹高度：height = 0.09765625
3 猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个；第二天早上又将剩下的桃子吃了一半，又多吃了一个；以后每天早上都吃了前天剩下的一半零一个；第十天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
x1=1
n1=9
while n1>0:
x1=(x1+1)*2
print("第%d天 \n剩余桃子数 %d"%(n1,x1))
n1=n1-1
第9天
剩余桃子数 4
第8天
剩余桃子数 10
第7天
剩余桃子数 22
第6天
剩余桃子数 46
第5天
剩余桃子数 94
第4天
剩余桃子数 190
第3天
剩余桃子数 382
第2天
剩余桃子数 766
第1天
剩余桃子数 1534
4 俩个乒乓球队进行比赛，各出三人。甲队为a,b,c 三人，乙队为x,y,z 三人，抽签决定比赛名单。有人向队员打听比赛名单。a说他不和x比，c说他不和x，z比，编程序找出三队的比赛名单。
for i in range(ord('x'),ord('z') + 1):
for j in range(ord('x'),ord('z') + 1):
if i != j:
for k in range(ord('x'),ord('z') + 1):
if (i != k) and (j != k):
if (i != ord('x')) and (k != ord('x')) and (k != ord('z')):
print ('order is a -- %s\t b -- %s\tc--%s' % (chr(i),chr(j),chr(k)))
order is a -- z b -- x c--y
5 找出数列第二大值
list = [1,2,8,4,23,4,11,77,54,14,12,17,64,21,7]
c = int(input(f'want : '))
for i in range(c): # 冒泡
for index in range(len(list) - 1):
i = list[index]
if i > list[index + 1]:
list[index] = list[index + 1]
list[index + 1] = i
print(list)
print(list[-2])
want : 2
[1, 2, 4, 4, 8, 11, 23, 14, 12, 17, 54, 21, 7, 64, 77]
64
6 判断是否为子列表
list = [1,2,8,4,23,4,11,77,54,14,12,17,64,21,7]
list2 = [1,3,7,8,22]
is_list = True
for i in list2:
if i not in list:
is_list = False
if is_list:
print("y")
else:
print('n')
7 取出离平均值最近的一个值 abs（）
list = [1,2,8,4,23,4,11,77,54,14,12,17,64,21,7]
a = max(list)
b = min(list)
c = (a + b) / 2
print(a,b,c)
close = list[0]
for n in list:
if abs(c - n) < abs(c - close):
close = n
print(close)
77 1 39.0
54
8 双色球
red = []
blue = []
list = [[6,33,'red',red],[2,16,'blue',blue]]
for item in list:
print(f'begin---{item[2]}'.center(50,'*'))
count = 0
while count < item[0] :
choise = input(f"选择第{count+1}个{item[2]} :").strip()
if not choise.isdigit():
print('false')
continue
choise = int(choise)
if 0 < choise < item[1] and choise not in item[3]:
item[3].append(choise)
count += 1
9 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标
# nums = input('>:').split()
# target = int(input('>:'))
nums = [1,2,3,4]
target = 6
lis = []
for i in range(len(nums)-1):
for j in range(i+1,len(nums)):
if nums[i] + nums[j] == target:
print([i,j])
# lis.append(i)
# lis.append(j)
break
6 使用元组，字典和集合
元组是只读列表，一旦创建不可修改。只可进行查询，切片，循环
1 使用元组类型
1 创建并访问元组
在Python程序中，创建元组的基本形式是以小括号“()”将数据元素括起来，各个元组之间用逗号“,”隔开。例如下面都是合法的元 组。 tup1 = ('Google', 'toppr', 1997, 2000); tup2 = (1, 2, 3, 4, 5 );
2 修改元组
在Python程序中，元组一旦创立后就是不可被修改的。但是在现实程序应用中，开发者可以对元组进行连接组合。
3 删除元组
在Python程序中，虽然不允许删除一个元组中的元素值，但是可以使用del语句来删除整个元组。
4 元组索引和截取
5 使用内置方法操作元组
len(tuple)：计算元组元素个数 max(tuple)：返回元组中元素最大值。 min(tuple)：返回元组中元素最小值。 tuple(seq)：将列表转换为元组。
car = ['aodi','baoma','bengchi','leikesasi']
print('列表长度：',len(car))
tuple2 = ('5','4','8')
print('最大值 ：',max(tuple2))
tuple3 = ('5','4','8')
print('最小值 ：',min(tuple3))
list1 = ['Goole','Taobao','Toppr','Baidu']
tuple1 = tuple(list1)
print('输出元组 ：',tuple1)
列表长度： 4
最大值 ： 8
最小值 ： 4
输出元组 ： ('Goole', 'Taobao', 'Toppr', 'Baidu')
2 使用字典
1 创建并访问字典
创建字典的语法格式如下所示： d = {key1 : value1, key2 : value2 } 在上述语法格式中，键“key:value”必须是唯一的，但值则不必。键值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。例如某个班级的期末考试成绩公布了，其中第1名非常厉害，学校准备给予奖励。
# 方法1
info = {
'name':'blackgirl',
'age':'22'
}
# 方法2
info = dict(name = 'blackgirl',age = 22)
2 向字典中添加数据
在Python程序中，字典是一种动态结构，可以随时在其中添加“键值”对。在添加“键值”对时，需要首先指定字典名，然后用中括号将键括起来，然后在最后写明这个键的值。
3 修改字典
在Python程序中，要想修改字典中的值，需要首先指定字典名，然后使用中括号把将要修改的键和对应的新值括起来。
info['name'] = 'blackgirl'
4 删除字典中的元素
在Python程序中，对于字典中不再需要的信息，可以使用del语句将相应的“键值”对信息彻底删除。在使用del语句时，必须指定字典名和要删除的键
name.pop('alec') # 删除指定key值
del names['black_girl'] # 删除指定key值，同pop方法
name.popitem() # 以LIFO的方式删除一对值 最后一个先出去
name.clear() # 清空dict
5 创建空字典
Python程序中，有时为了满足项目程序的特定需求，需要创建一个空字典。此时可以先使用一对空的大括号定义一个字典，然后再分行添加各个“键值”对。
6 和字典有关的内置函数
len(dict) ：计算字典元素个数，即键的总数。 str(dict)：输出字典以可打印的字符串表示。 type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。
7 循环
for k in dic.keys() for k,v in dic.items() for k in dic # 推荐用这种，效率速度最快
3 遍历字典
1 一次性遍历所有的“键值”对
在Python程序中，可以使用for..in循环语句一次性遍历所有的“键值”对。
favorite_languages = {
'张三': 'python' ,
'李四': 'c' ,
'王五': 'rubby' ,
'赵六': 'java',
}
for key,value in favorite_languages.items():
print("\n key :"+key)
print("value :"+ value)
key :张三
value :python
key :李四
value :c
key :王五
value :rubby
key :赵六
value :java
2 遍历字典中的所有键
在Python中，使用内置方法 keys() 能后以列表的形式返回一个字典中的所有键。
dict.keys()
方法 keys() 没有参数，只有返回值，返回一个字典中所有的键。
favorite_languages = {
'张三': 'python' ,
'李四': 'c' ,
'王五': 'rubby' ,
'赵六': 'java',
}
for name in favorite_languages.keys():
print(name.title())
张三
李四
王五
赵六
3 按序遍历字典中的所有键
favorite_languages = {
'张三': 'python' ,
'李四': 'c' ,
'王五': 'rubby' ,
'赵六': 'java',
}
for name in sorted(favorite_languages.keys()):
print(name.title())
张三
李四
王五
赵六
4 遍历字典中的所有值
在Python中，可以用方法 values() 返回一个字典中的所有值，而不包含任何键。
dict.values()
方法values() 没有参数，只有返回值，返回字典中的所有值。
favorite_languages = {
'张三': 'python' ,
'李四': 'c' ,
'王五': 'rubby' ,
'赵六': 'java',
}
print(list(favorite_languages.values()))
['python', 'c', 'rubby', 'java']
4 字典嵌套
有时候需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套。可以在列表中嵌套字典，也可以在字典中嵌套列表，甚至可以在字典中嵌套字典。
1 字典列表
stu = []
for stu_num in range(0,30):
new_stu = {'语文：':'90','数学':'100','英语':'100'}
stu.append(new_stu)
for stus in stu[0:5]
print(stus)
{'语文：': '90', '数学': '100', '英语': '100'}
{'语文：': '90', '数学': '100', '英语': '100'}
{'语文：': '90', '数学': '100', '英语': '100'}
{'语文：': '90', '数学': '100', '英语': '100'}
{'语文：': '90', '数学': '100', '英语': '100'}
2 在字典中存储字典
users = {'小王':{'密码':'12345678','电话':'12322132'},
'小李':{'密码':'45623434','电话':'44542132'}
}
for username,user_info in users.items():
print("\n username:"+username)
full_name = user_info['密码']
location = user_info['电话']
print(" mm :"+full_name.title())
print(" tel :" + location.title())
username:小王
mm :12345678
tel :12322132
username:小李
mm :45623434
tel :44542132
3 在字典中存储列表
miantiao = {
'主食':'面条',
'配料':['加肉','加辣']
}
print("你点了一份："+miantiao['主食'] )
for topping in miantiao['配料']:
print("\t"+topping)
你点了一份：面条
加肉
加辣
5 使用其他内置方法
1 使用方法clear()清空字典
dict() 函数用于创建一个字典。
dict = {'Name':'Zara','Age':7}
print("字典长度： %d" % len(dict))
dict.clear()
print("字典删除后长度 ： %d" % len(dict))
字典长度： 2
字典删除后长度 ： 0
2 使用方法copy()复制字典
dict = {'Name':'Zara','Age':7}
dict2=dict.copy()
print("复制的字典：",dict2)
复制的字典： {'Name': 'Zara', 'Age': 7}
3 使用方法fromkeys()创建字典
seq = ('name','age','sex')
dict1 = dict.fromkeys(seq)
print("新的字典为： %s"% str(dict1))
dict2 = dict.fromkeys(dict1,10)
print("新的字典为： %s"% str(dict2))
新的字典为： {'name': None, 'age': None, 'sex': None}
新的字典为： {'name': 10, 'age': 10, 'sex': 10}
4 使用方法get()获取指定的键值
dict = {'name':'su','age':20}
print("age的值为： %s"% dict.get('age'))
print("sex值为： %s"% dict.get('sex','男'))
age的值为： 20
sex值为： 男
5 使用方法setdefault()获取指定的键值
dict = {'name':'su','age':20}
print("age键的值为： %s"% dict.setdefault('age',None))
print("sex键的值为： %s"% dict.setdefault('sex',None))
print("新字典为：",dict)
age键的值为： 20
sex键的值为： None
新字典为： {'name': 'su', 'age': 20, 'sex': None}
6 使用方法update()修改字典
合并修改
dict = {'name':'su','age':20}
dict2 = {'sex':'female'}
dict.update(dict2)
print("新字典为：",dict)
新字典为： {'name': 'su', 'age': 20, 'sex': 'female'}
6 使用集合 set
集合里面的值不可变，只能存储不可变的值，不可存 list，dict。可以存字符串，数字，元组等不可变类型
集合天生去重，集合里不能存储重复的元素
无序，不能像列表一样通过索引来标记在列表中的位置，元素是无序的，集合中的元素没有先后之分，如集合{3，4，5}和集合{3，5，4}算作同一个集合
关系测试，
集合（set）是一个无序不重复元素的序列。集合的基本功能是进行成员关系测试并删除重复的元素。Python语言规定使用大括号“{}”或者函数set（）创建集合。在创建一个空集合时必须用函数set()实现，而不能使用大括号“{}”实现。这是因为空的大括号“{}”是用来创建一个空的字典的。
1 创建集合
可以通过set()，也可以通过 a={1},用大括号，括号里写一个东西才是集合，否则是字典
a = set() type(a) <class 'set'> a ={} type(a) <class 'dict'> a = {1} type(a) <class 'set'>
2 帮列表去重
a = list (set(a))
3 增
a . add('value')
4 查
8 in a
False
5 改
不能修改里里面的值
6 删除
a.pop() # 随机删除一个值，并返回该值
a.remove(3) # 删除3个元素，若3不在，报KeyError
a.discard() # 删除指定的值，若该值不在，do nothing
7 关系测试
判断子集父集
b.issubset(a)
a.issuperset(b)
a为父集，b为子集，返回True
student = {'tt','jj','mm','bb'}
print(student)
if('bb' in student):
print('bb in student')
else:
print('bb not in student')
a = set('abcde')
b = set('abc')
print("a = ",a)
print("a - b = ",a - b) # a和b的差集
print("a | b =",a | b) # a和b的并集
print("a & b =",a & b) # a和b的交集
print("a ^ b =",a ^ b) # a和b中不同时存在的元素，对称差集
{'mm', 'jj', 'tt', 'bb'}
bb in student
a = {'e', 'b', 'd', 'c', 'a'}
a - b = {'e', 'd'}
a | b = {'b', 'e', 'c', 'd', 'a'}
a & b = {'c', 'b', 'a'}
a ^ b = {'e', 'd'}
测试后修改
>>> a = set('abcde')
>>> b = set('abc')
>>> a
{'e', 'a', 'c', 'd', 'b'}
>>> b
{'a', 'b', 'c'}
>>> a.difference(b)
{'e', 'd'}
>>> a
{'e', 'a', 'c', 'd', 'b'}
>>> a.difference_update(b)
>>> a
{'e', 'd'}
>>> a.update(b)
>>> a
{'e', 'a', 'c', 'd', 'b'}
>>>
7 类型转换
1 内置类型转换函数
通过内置函数可以实现数据类型转换功能，这些函数能返回一个新的对象，表示转换的值。
int(x[,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象x转换为字符串
repr(x) 将对象x转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式，并返回一个对象
tuple(s) 将序列s转换为一个元组
list(s) 将序列s转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d必须是一个序列(key,value)元组
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串
2 类型转换综合演练
# 类型转换
# convert
# 转换为int类型
print('int()默认情况下为：', int())
print('str字符型转换为int：', int('010'))
print('float浮点型转换为int：', int(234.23))
# 进制数10，对应的2进制，8进制，10进制，16进制分别是：1010,12,10,0xa
print('int(\'0xa\', 16) = ', int('0xa', 16))
print('int(\'10\', 10) = ', int('10', 10))
print('int(\'12\', 8) = ', int('12', 8))
print('int(\'1010\', 2) = ', int('1010', 2))
# 换为long类型
print('int浮点型转换为int：', int(23))
# 转换为float类型
print('float()默认情况下为：', float())
print('str字符型转换为float：', float('123.01'))
print('int浮点型转换为float：', float(32))
# 转换为complex类型
print('创建一个复数(实部+虚部)：', complex(12, 43))
print('创建一个复数(实部+虚部)：', complex(12))
#转换为str类型
print('str()默认情况下为：', str())
print('float字符型转换为str：', str(232.33))
print('int浮点型转换为str：', str(32))
lists = ['a', 'b', 'e', 'c', 'd', 'a']
print('列表list转换为str:', ''.join(lists))
#转换为list类型
strs = 'hongten'
print('序列strs转换为list:', list(strs))
#转换为tuple类型
print('列表list转换为tuple:', tuple(lists))
print('列表strs转换为tuple:', tuple(strs))
#字符和整数之间的转换
#字符转换为int类型
print('整数转换为字符chr:', chr(67))
# print('整数转换为字符Unicode:', unichr(67))
# python 3 不支持unichr 改用chr
print('字符chr转换为整数:', ord('C'))
print('整数转16进制数:', hex(1111))
print('整数转8进制数:', oct(20))
int()默认情况下为： 0
str字符型转换为int： 10
float浮点型转换为int： 234
int('0xa', 16) = 10
int('10', 10) = 10
int('12', 8) = 10
int('1010', 2) = 10
int浮点型转换为int： 23
float()默认情况下为： 0.0
str字符型转换为float： 123.01
int浮点型转换为float： 32.0
创建一个复数(实部+虚部)： (12+43j)
创建一个复数(实部+虚部)： (12+0j)
str()默认情况下为：
float字符型转换为str： 232.33
int浮点型转换为str： 32
列表list转换为str: abecda
序列strs转换为list: ['h', 'o', 'n', 'g', 't', 'e', 'n']
列表list转换为tuple: ('a', 'b', 'e', 'c', 'd', 'a')
列表strs转换为tuple: ('h', 'o', 'n', 'g', 't', 'e', 'n')
整数转换为字符chr: C
字符chr转换为整数: 67
整数转16进制数: 0x457
整数转8进制数: 0o24
8 技术解惑
在字典遍历过程中修改字典元素，报错 RuntimeError: dictionary changed size during iteration，得知遍历时不能修改字典元素
d = {'a':1,'b':0,'c':1,'d':0}
for k in d :
if d[k] == 0:
del(d[k])
for k in d :
RuntimeError: dictionary changed size during iteration
d = {'a':1,'b':0,'c':1,'d':0}
for k in list(d.keys()):
if d[k]==0:
del(d[k])
print(d)
{'a': 1, 'c': 1}
字典dict中某些特定值删除的简单代码
以下字典，在python 3 版本以上，以字典a举例，删除value为0的键值对（或元素），其他比如：删除key中包含哪些值的键值对
简单写下：
1.第一种用zip() 函数，for循环遍历a种的所有keys和values，attend两个列表
a ``=` `{``1``:``0``,``2``:``1``,``3``:``0``,``4``:``1``}``
list1 ``=` `[] `
list2 ``=` `[]``
for` `k,v ``in` `a.items():`` ``
if` `v !``=``0``:`` ``
list1.append(k)`` ``
list2.append(v)``
a ``=` `dict``(``zip``(list1,list2))``
print``(a)
2.第二种，两次for循环和del，第一次对keys循环，再次对list循环，del
a ``=` `{``1``:``0``,``2``:``1``,``3``:``0``,``4``:``1``}``
list1 ``=` `[]``
for` `k ``in` `a: ``# 同：for k in a.keys() # 遍历出的结果为key，attend至list1`` ``
list1.append(k) ``
for` `v ``in` `list1: ``# 遍历上面list1`` ``
if` `a[v] ``=``=` `0``:`` ``
del` `a[v]``print``(a)
3.第三种，相当于第二种简写
a ``=` `{``1``:``0``,``2``:``1``,``3``:``0``,``4``:``1``}``
for` `k ``in` `list``(a.keys()): ``#对字典a中的keys，相当于形成列表list`` ``
if` `a[k] ``=``=` `0``:`` ``
del` `a[k]``
、print``(a)
9 课后练习
1 输出菱形
for i in range(1, 5):
print(' ' * (4 - i), end="") # end=''表示最后以一个bai空格结束而不换行。
for j in range(1, 2 * i):
print('*', end="")
print() # 第一、正常情况下，print() 自带了‘\n’.所以，print()即为一个\n
# 第二、配合print（'',end = ''）使用。使光标保持在同一行行。
for i in range(3, 0, -1):
print(' ' * (4 - i), end="")
for j in range(1, 2 * i):
print('*', end="")
print()
*
***
*****
*******
*****
***
*
代码简化
for i in range(1, 5):
print(' ' * (4 - i), end="")
print('*'*(2*i-1))
for i in range(3, 0, -1):
print(' ' * (4 - i), end="")
print('*'*(2*i-1))
2 有一分数序列：2/1，3/2，5/3，8/5，········求出这个数列的二十项之和。
sum = 0
a, b = 1, 2
for i in range(1, 21):
sum += b / a
a, b = b, a + b
print(b,end=' ')
print(a)
print(sum)
3 2
5 3
8 5
13 8
21 13
34 21
55 34
89 55
144 89
233 144
377 233
610 377
987 610
1597 987
2584 1597
4181 2584
6765 4181
10946 6765
17711 10946
28657 17711
32.66026079864164
3 求1+2！+3！+·····+20！的和
s = 1
t = []
for i in range(1,21):
s *= i
t.append(s)
print(sum(t)-1)
4 用递归法求5！的值
def fun(n):
if n==1 or n==0:
return 1
else:
return fun(n-1)*n
i = 5
print(fun(i))
5 生成一个包含100个key的字典，每个value值不一样
# dic = {}
# n = 0
# for i in range(1,101):
# # n += 1
# dic[i] = 0
# print(dic)
6 把dict中key大于3的值打印出来
dic = {'k0':0,'k1':1,'k2':2,'k3':3,'k4':4,'k5':5,'k6':6}
lis = []
for key in dic.keys():
if key > 'k3':
lis.append(dic[key])
print(lis)
7 把value是偶数的改为 -1
dic = {'k0':0,'k1':1,'k2':2,'k3':3,'k4':4,'k5':5,'k6':6}
for key in dic.keys():
if dic[key] % 2 == 0:
dic[key] = -1
print(dic)
8 把列表中的值进行分类
test_list = [4,6,6,4,2,2,4,5,5,6,6,7,8]
dic = {}
for i in test_list:
if i not in dic:
dic[i] = [i,]
else:
dic[i].append(i)
print(dic)
9 将一段话中的重复单词删除
str_dict = {}
str_dict1 = {}
str_dict2 = {}
str_input = input('输入：') # 输入
str_list = str_input.split() # 先生成一个列表
len_list = len(str_list)
for i in range(len_list):
str_dict[i] = [i,] # 生成一个key和value相同的字典
print(f'str_dict{str_dict}')
print(f'str_list{str_list}')
for i in str_list:
if i not in str_dict: # 删除重复的单词
str_dict1[i] = i
print(f'str_dict1{str_dict1}') # 生成一个key和value相同的字典
print(list(str_dict1.values())) # 将字典中的value放到列表中，删除了重复的value
s = ''
for i in range(len(list(str_dict1.values()))):
s = s + ' ' + list(str_dict1.values())[i] # 生成一条字符串
print(f'resualt:{s}')
for key in str_list:
str_dict2[key] = str_dict2.get(key,0) + 1 # 统计单词重复的次数，生成字典
print('str_dict2',str_dict2)
运行：
输入：pp p p p sii is is g g gg
str_dict{0: [0], 1: [1], 2: [2], 3: [3], 4: [4], 5: [5], 6: [6], 7: [7], 8: [8], 9: [9]}
str_list['pp', 'p', 'p', 'p', 'sii', 'is', 'is', 'g', 'g', 'gg']
str_dict1{'pp': 'pp', 'p': 'p', 'sii': 'sii', 'is': 'is', 'g': 'g', 'gg': 'gg'}
['pp', 'p', 'sii', 'is', 'g', 'gg']
resualt: pp p sii is g gg
str_dict2 {'pp': 1, 'p': 3, 'sii': 1, 'is': 2, 'g': 2, 'gg': 1}
10 输出dict中value里唯一的值
lis = []
dic = {'gfg':[5,6,7,8],'beat':[6,12,10,8],'is':[10,11,7]}
for key in dic: # key在dict中
for i in dic[key]: # value中的列表
if i not in lis:
lis.append(i)
lis.sort() # 排序从小到大
print(lis)
运行：
[5, 6, 7, 8, 10, 11, 12]
11 把下表中同字母不同序的放到一个列表中
arr = ['act','cat','dog','god']
dic = {}
for j in arr:
i = list(j) # 变成一个列表
i.sort() # 排序从小到大
to_key = tuple(i) # 转为元组作为key值
if to_key not in dic:
dic[to_key] = [j] # key值为元组to_key，value值为j
else:
dic[to_key].append(j)
print(list(dic.values())) # 转为列表
12 创建一个三级菜单
menu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
'山东':{},
}
center_lay = menu
lay = []
while True:
for key in center_lay: # 判断输入的 key 是否在字典中
print(key) # 如果在输出 key
print('输入当前菜单内容，进入下一级，输入b返回上一级，输入q退出！')
choise = input('>:').strip() # 输入
if not choise:continue # 如果没输入就继续
if choise in center_lay: # 判断输入是否在字典中
lay.append(center_lay) # 如果在在字典中，添加到列表里
center_lay = center_lay[choise] # 重新创建列表
elif choise =='b':
if len(lay) != 0:
center_lay = lay.pop() # 默认删除最后一个列表值
else:
print("已经是顶层")
elif choise == 'q':
exit()
运行：
北京
上海
山东
输入当前菜单内容，进入下一级，输入b返回上一级，输入q退出！
>:北京
海淀
昌平
朝阳
东城
输入当前菜单内容，进入下一级，输入b返回上一级，输入q退出！
>:海淀
五道口
中关村
上地
输入当前菜单内容，进入下一级，输入b返回上一级，输入q退出！
>:b
海淀
昌平
朝阳
东城
输入当前菜单内容，进入下一级，输入b返回上一级，输入q退出！
>:b
北京
上海
山东
输入当前菜单内容，进入下一级，输入b返回上一级，输入q退出！
>:q
7 使用函数
1 函数基础
1 定义函数
在Python程序中，在使用函数之前必须先定义（声明）函数，然后才能调用它。在使用函数时，只要按照函数定义的形式，向函数传递必需的参数，就可以调用函数完成相应的功能或者获得函数返回的结果。
在Python程序中，使用关键字def可以定义一个函数，定义函数的语法格式如下所示：
def <函数名> (参数列表) ：
<函数语句>
return<返回值>
在上述格式中，参数列表和返回值不是必须的，retum后也可以不跟返回值，甚至连return也没有。如果retum后没有返回值的，并且没有return语句，这样的函数都会返回None值。有些函数可能既不需要传递参数，也没有返回值。
def hello() : # 定义函数hello()
print("Hello World !") # 该行属于函数hello()的内容
hello()
Hello World !
与C语言中的函数的声明相比，在Python中声明一个函数不需要声明函数的返回值类型，也不需要声明参数的类型。
你可以定义一个由自己想要功能的函数，以下是简单的规则：
-
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
-
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
-
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
-
函数内容以冒号 : 起始，并且缩进。
-
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。
2 调用函数
调用函数就是使用函数，在Python程序中，当定义一个函数后，就相当于给了函数一个名称，指定了函数里包含的参数，和代码块结构。完成这个函数的基本结构定义工作后，就可以通过调用的方式来执行这个函数，也就是使用找个函数。在Python程序中，可以直接从 Python命令提示符执行一个已经定义了的函数。
def tpl_sum(T) :
result = 0
for i in T :
result += i
return result
print("(1,2,3,4)元组中元素的和为：",tpl_sum((1,2,3,4)))
# 使用函数tpl_sum()计算元组内元素的和
print("[3,4,5,6]列表中元素的和为：",tpl_sum([3,4,5,6]))
# 使用函数tpl_sum()计算列表内元素的和
print("[2.7,2,5.8]列表中元素的和为：",tpl_sum([2.7,2,5.8]))
# 使用函数tpl_sum()计算列表内元素的和
print("[1,2,2.4]列表中元素的和为：",tpl_sum([1,2,2.4]))
# 使用函数tpl_sum()计算列表内元素的和
(1,2,3,4)元组中元素的和为： 10
[3,4,5,6]列表中元素的和为： 18
[2.7,2,5.8]列表中元素的和为： 10.5
[1,2,2.4]列表中元素的和为： 5.4
2 函数的参数
Python中函数的参数有多种形式，在调用某个函数时，既可以向其传递参数，也可以不传递参数，但是这都不影响函数的正常调用。另外还有一些情况，比如函数中的参数数量不确定，可能为1个，也可能为几个甚至几十个。
1 形参和实参
在Python程序中，形参表示函数完成其工作所需的一项信息。而实参是调用函数时传递给函数的信息。初学者有时候会形参、实参不分，因此如果你看到有人将函数定义中的变量称为实参或将函数调用中的变量称为形参，不要大惊小怪
下面是在调用函数时可以使用的正式实参类型。
必需参数
关键字参数
默认参数
不定长参数
2 必需参数
在Python程序中，必需参数也被称为位置实参，在使用时必须以正确的顺序传入函数。并且调用函数时，必需参数的数量必须和声明时的一样
def printme(str) :
"打印任何转入的字符串"
print(str)
return
printme()
printme()
TypeError: printme() missing 1 required positional argument: 'str'
def printme(str) :
"打印任何转入的字符串"
print(str)
return
printme("hello")
printme("world")
hello
world
必备函数（位置函数）
必备，不传值会报错
传的值是有顺序的，从左到右，每个参数一一对应
def stu_form(name, age, major, phone):
info = f'''
name : {name},
age : {age},
major : {major},
phone : {phone}
'''
print(info)
stu_form('su',25,'student') # 少一个参数
运行：
Traceback (most recent call last):
File "D:/pycharm/xx/zuoye1.py", line 593, in <module>
stu_form('su',25,'student')
TypeError: stu_form() missing 1 required positional argument: 'phone'
3 关键字参数
在Python程序中，关键字参数和函数调用关系紧密。在调用函数时，通过使用关键字参数可以确定传入的参数值。在使用关键字参数时，允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
位置参数不能放到关键字参数后面
使用关键字参数
def printme(str) : # 定义函数printme()
"打印任何转入的字符串"
print(str) # 显示函数的参数
return
printme(str = "练习") # 调用函数printme()，设置参数str的值是“练习”
练习
在上述代码中，设置了函数printme()的参数值为“练习”。
不需要指定函数参数的顺序
def printinfo(name,age) : # 定义函数
"打印任何转入的字符串"
print("名字： ",name) # 显示函数的参数name
print("年龄： ",age) # 显示函数的参数age
return
printinfo(age=10,name="TT")
名字： TT
年龄： 10
4 默认参数
当在Python程序中调用函数时，如果没有传递参数，则会使用默认参数（也被称为默认值参数）。
def printinfo(name,age=12) :
"打印任何转入的字符串"
print("名字： ",name)
print("年龄： ",age)
return
printinfo(age=20,name="TT")
print("--------------------")
printinfo(name="GG")
名字： TT
年龄： 20
--------------------
名字： GG
年龄： 12
5 不定长参数
Python中，可能需要一个函数能处理比当初声明时更多的参数，这些参数叫作不定长参数。不定长参数也称为可变参数。和前面介绍的参数类型不同，声明不定长参数时不会命名，基本语法格式如下：
def functionname([formal_args,] *var_args_tuple ) : "函数_文档字符串" function_suite return [expression]
加了星号的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组，开发者也可以不向函数传递未命名的变量。由此可见，在自定义函数时，如果参数名前加上一个星号，则表示该参数就是一个可变长参数。在调用该函数时，如果依次序将所有的其他变量都赋予值之后，剩下的参数将会收集一个元组中，元组的名称就是前面带星号的参数名。
def printinfo(arg1,*vartuple) : # 定义函数printinfo(),参数vartuple是不定长参数
"显示任何传入的参数"
print("输入：") # 显示文本
print(arg1) # 显示参数arg1
for var in vartuple : # 循环遍历参数vartuple
print(var) # 显示遍历到的参数vartuple
return
printinfo( 10 ) # 调用函数printinfo()
printinfo( 70, 60, 50 ) # 参数vartuple是不定长参数，所以本行代码合法
输入：
10
输入：
70
60
50
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Phoebe", "Jennifer", "Rory")
运行：
The youngest child is Rory
**kwargs字典传值
接收多余的关键字参数，并以dict形式给到kwargs
def stu_form(name, age, major, phone,nationlity = 'cn',*args,**kwargs):
info = f'''
name : {name},
age : {age},
major : {major},
phone : {phone}
nationlity : {nationlity}
'''
print(info)
print('不定长列表参数 ：',args) # 元组形式
print('不定长列表参数 ：',kwargs) # 字典形式
stu_form('su',25,'student',1333331,'Americ','tony','movies',hometown = 'henan',university = 'qinghua') # 多写了俩个指定参数
运行：
name : su,
age : 25,
major : student,
phone : 1333331
nationlity : Americ
不定长列表参数 ： ('tony', 'movies')
不定长列表参数 ： {'hometown': 'henan', 'university': 'qinghua'}
6 按 值传递参数和按引用传递参数
在 Python程序中，函数参数传递机制问题在本质上是调用函数（过程）和被调用函数（过程）在调用发生时进行通信的方法问题。基本的参数传递机制有两种，分别是按值传递和按引用传递。
（1）按值传递 Pass-By-Value：被调函数的形参作为被调函数的局部变量来处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而使该值成为一个实参的副本。按值传递的特点是被调函数对形参的任何操作都作为局部变量进行，不会影响主调函数的实参变量的值。
（2）按引用传递 Pass-By-Reference：被调函数的形参虽然也作为局部变量在堆栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过堆栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。
def changeme(mylist) :
"修改传入的列表"
mylist.append([1,2,3,4])
# 向参数mylist中添加一个列表
print("函数内的取值：",mylist)
return
mylist = [10,20,30] # 设置mylist的值是一个列表
changeme(mylist)
print("函数外的取值：",mylist)
函数内的取值： [10, 20, 30, [1, 2, 3, 4]]
函数外的取值： [10, 20, 30, [1, 2, 3, 4]]
调用的参数为列表和字典
def stu_form(name, age, major, phone,nationlity = 'cn',*args,**kwargs):
info = f'''
name : {name},
age : {age},
major : {major},
phone : {phone}
nationlity : {nationlity}
'''
print(info)
print('不定长列表参数 ：',args)
print('不定长列表参数 ：',kwargs)
my_info = ['su',25,'student',1333331,'Americ','study'] # 列表
my_dict = {
'name':'li',
'age':20,
'major':'teacheer',
'phone':2222222,
'hobbie':'game'
} # 字典
stu_form(*my_info) # 调用列表里的值
stu_form(**my_dict) # 调用字典里的值
运行：
name : su,
age : 25,
major : student,
phone : 1333331
nationlity : Americ
不定长列表参数 ： ('study',)
不定长列表参数 ： {}
name : li,
age : 20,
major : teacheer,
phone : 2222222
nationlity : cn
不定长列表参数 ： ()
不定长列表参数 ： {'hobbie': 'game'}
7 传值类型
1 不可变类型
在函数内修改外部传进来的不可变类型时，会在函数内部生成一个该参数的copy，并不会影响原来函数外部的值
2 可变类型
可变类型，如列表，dict，传到函数内部，其实只是传递了改列表\dict的整体内存地址，函数内部可直接修改函数外部的这个list or dict
def chang_data(name,hobbies):
name = 'su' # 修改只在函数内生效
hobbies.append('保健') # 在函数内往外部列表添加值
hobbies[1] = 'xiaoyun' # 修改列表元素
print('in func:',name,hobbies)
my_name = "苏" # 不可变类型
my_hobbies = ['money','black'] # 可变类型
chang_data(my_name,my_hobbies)
print(my_name,my_hobbies)
运行：
in func: su ['money', 'xiaoyun', '保健']
苏 ['money', 'xiaoyun', '保健']
3 函数的返回值
在Python中，函数可以使用return语句将值返回到调用函数的代码行。
1 返回一个简单值
在 Python程序中，函数可以使用return语句将值返回到调用函数的代码行。 在 Python程序中，对函数返回值的最简单用法就是返回一个简单值，例如返回一个文本单词。
def get_name(first_name,last_name):
"""返回一个简单的值："""
full_name = first_name + " " + last_name
return full_name.title()
jiandan = get_name('su','yong') # 调用函数get_name
print(jiandan) # 显示俩个参数的内容
Su Yong
2 可选实参
有时需要让实参变成一个可选参数，这样函数的使用者只需在必要时才提供额外的信息。在Python程序中，可以使用默认值来让实参变成可选的。
# 定义函数get_name()，其中middle_name是可选参数
def get_name(first_name,last_name,middle_name=''):
"""返回一个简单的值："""
full_name = first_name + " " + middle_name+ ' ' +last_name
return full_name.title()
jiandan = get_name('su','li','yong') # 调用函数get_name
print(jiandan) # 显示俩个参数的内容
Su Yong Li
3 返回一个字典
def person(first_name,last_name,age=''): # 定义函数person
"""返回一个字典"""
person = {'first':first_name,'last':last_name} # 将参数封装在字典person中
if age :
person['age'] = age # 设置字典person中的age就是参数age的值
return person
musician = person('i','love',age=8) # 调用函数person()
print(musician)
{'first': 'i', 'last': 'love', 'age': 8}
在Python程序中，函数可返回任意类型的值，包括列表和字典等较复杂的数据结构。
4 返回多个值
def stu_registriation_form():
form={
'name': input('name :').strip(),
'age': input('age :').strip(),
'phone': input('phone :').strip()
}
info_pass_flag = True
for k,v in form.items():
if len(v) == 0: # 没写东西
info_pass_flag=False
break
return form,info_pass_flag
stu_info,flag = stu_registriation_form() # 接收2个值
print(stu_info)
print(flag)
if not flag:
print('表单有误')
4 函数的嵌套
def stu_form():
form = {
'name' :input('name:').strip(),
'age':input('age').strip(),
'major':input('major:').strip() ,
'phone':input('phone:').strip()
}
print(form)
def chang_form(form_data):
print(form_data.keys())
print('-----------chang_data---------------')
while True:
key = input('输入要修改的key>>:').strip()
if not key:continue
if key in form_data.keys():
print(f'{key}的当前值为{form_data[key]}')
key_new_val = input('输入要修改的新值 ;').strip()
form_data[key] = key_new_val
break
else:
print('不合法key')
chang_form(form)
print('new form :',form)
return form
stu_form()
运行：
name:su
age20
major:teacher
phone:122223333
{'name': 'su', 'age': '20', 'major': 'teacher', 'phone': '122223333'}
dict_keys(['name', 'age', 'major', 'phone'])
-----------chang_data---------------
输入要修改的key>>:age
age的当前值为20
输入要修改的新值 ;25
new form : {'name': 'su', 'age': '25', 'major': 'teacher', 'phone': '122223333'}
5 变量的作用域
变量的作用域是指变量的作用范围，即这个变量在什么范围内起作用。
局部作用域：定义在函数内部的变量拥有一个局部作用域，表示只能在其被声明的函数内部访问。 全局作用域：定义在函数外的拥有全局作用域，表示可以在整个程序范围内访问。在调用一个函数时，所有在函数内声明的变量名称都将被加入到作用域中。 内置作用域：Python预先定义的。
每当执行一个Python函数时，都会创建一个新的命名空间，这个新的命名空间就是局部作用域。如果同一个函数在不同的时间运行，那么其作用域是独立的。不同的函数也可以具有相同的参数名，其作用域也是独立的。在函数内已经声明的变量名，在函数以外依然可以使用。另外，在程序运行的过程中，其值并不相互影响。
使用相互不影响的同名变量
def myfun() : # 定义函数myfun()
a = 0 # 声明变量a，初始值为0
a += 3 # 变量a的值加3
print('函数内a：',a)
a = 'external' # 函数外赋值a
print('全局作用域a：',a) # 显示函数外赋值
myfun() # 显示函数内赋值
print('全局作用域a：',a) # 再次显示函数外赋值
全局作用域a： external
函数内a： 3
全局作用域a： external
使用关键字global在函数内部使用全局变量
def myfun() : # 定义函数myfun()
global a
a = 0 # 声明变量a，初始值为0
a += 3 # 变量a的值加3
print('函数内a：',a)
a = 'external' # 函数外赋值a
print('全局作用域a：',a) # 显示函数外赋值
myfun() # 显示函数内赋值
print('全局作用域a：',a) # 再次显示函数外赋值
全局作用域a： external
函数内a： 3
全局作用域a： 3
6 使用函数传递列表
在Python中，有时需要使用函数传递列表，在这类列表中可能包含名字，数字或更复杂的对象（比如字典）。将列表传递给函数后，函数就可以直接访问其内容。
1 访问列表中的元素
def users(names):
"""向我的每一位好友打一个招呼"""
for name in names : # 遍历参数names中的每一个值
msg = "Hello," + name.title() + "!"
# 设置问候语msg
print(msg) # 显示问候语msg
usersnames = ['花花','明明','小小']
# 设置参数列表值
users(usersnames)
Hello,花花!
Hello,明明!
Hello,小小!
2 在函数中修改列表
当将列表中的信息传递给函数后，函数就可以对其进行修改。通过在函数中对列表进行修改的方式，可以高效地处理大量的数据。
def copy(friend,relatives) : # 定义函数copy,负责复制好友
while friend:
current_design = friend.pop()
# 从copy列表中复制
print("复制好友：" + current_design)
relatives.append(current_design)
def qinren(relatives):
print("\n 下面的好友已经被复制到“亲人“分组中！")
for completed_model in relatives:
print(completed_model)
friend = ['花花','明明','小小']
relatives = []
copy(friend,relatives)
qinren(relatives)
print('亲人列表：'+str(relatives))
复制好友：小小
复制好友：明明
复制好友：花花
下面的好友已经被复制到“亲人“分组中！
小小
明明
花花
亲人列表：['小小', '明明', '花花']
7 使用匿名函数
在Python程序中，可以使用lambda来创建匿名函数。所谓匿名，是指不再使用 def 语句这样标准的形式定义一个函数。也可以将匿名函数赋给一个变量供调用，它是Python中一类比较特殊的声明函数的方式，lambda来源于LISP语言，其语法格式如下所示： lambda params:expr
参数“params”相当于声明函数时的参数列表中用逗号分隔的参数，参数’expr‘使函数要返回的值的表达式，而表达式中不能包含其他语句，也可以返回元组（要用括号），并且允许在表达式中调用其他函数。
lambda 只是一个表达式，函数体比 def 简单很多。 lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。 lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
sum = lambda arg1,arg2: arg1 + arg2
# 调用sum函数
print("相加后的值为：",sum(10,20))
print("相加后的值为：",sum(20,20))
相加后的值为： 30
相加后的值为： 40
>> func = lambda x,y:x*y
>> fun(8,9)
72
# 相当于传统函数
def func(x,y):
return x*y
通常使用 lambda 定义如下类型的函数
简单匿名函数：写起来快速而简单，节省代码
不复用的函数：在有些时候需要一个抽象简单的功能，又不想单独定义一个函数
为了代码清晰：有些地方使用它，代码更清晰易懂
如果某个函数中需要一个重复使用的表达式，就可以使用 lambda 来定义一个匿名函数。当发生多次调用时，就可以减少代码的编写量，使条理变得更加清晰
8 函数和模块开发
1 导入整个模块文件
在Python程序中，导入模块的方法有多种，下面将首先讲解导入整个模块的方法。要想让函数变为是可导入的，需要先创建一个模块。模块是扩展名是“.py”格式的文件，在里面包含了要导入到程序中的代码。
text.py
import pizza
pizza.make(16,'黄油','虾','芝士')
pizza.make(12,'黄油')
pizza.py
def make(size,*toppings) :
print("\n 制作一个" + str(size) + "寸的披萨需要的配料")
for topping in toppings :
print("-" + topping)
制作一个16寸的披萨需要的配料
-黄油
-虾
-芝士
制作一个12寸的披萨需要的配料
-黄油
如果使用这种 import 语句导入了名为 module_name.py 的整个模块，就可以通过下面的语法使用其中的任何一个函数。
module_name.function_name
2 只导入指定的函数
Python程序中，还可以根据项目的只导入模块文件中的特定函数，这种导入方法的语法格式如下所示。 from module_name import function_name 如果需要从一个文件中导入多个指定的函数，可以使用逗号隔开多个导入函数的名称。具体语法格式如下所示： from module_name import function_name0, function_name1, function_name2
text.py
def printinfo(arg1,*vartuple):
"显示任何传入的参数"
print("输出：") # 显示文本
print(arg1) # 显示参数arg1
print('----------------------')
for var in vartuple : # 遍历参数vartuple中的值
print(var) # 显示遍历到的值
return
from text import printinfo printinfo(10) printinfo(70,60,50) 输出： 10 输出： 70 60 50
3 使用as指定函数别名
在Python程序中，如果要从外部模板文件中导入的函数名称可能与程序中现有的名称发生冲突，或者函数的名称太长，可以使用关键字“as”指定简短而独一无二的别名。
def printinfo(arg1,*vartuple):
"显示任何传入的参数"
print("输出：") # 显示文本
print(arg1) # 显示参数arg1
for var in vartuple : # 遍历参数vartuple中的值
print(var) # 显示遍历到的值
return
from text import printinfo as mm # 将函数printinfo()设置为别名“mm” mm(10) # 相当于调用函数printinfo() mm(70,60,50) # 相当于调用函数printinfo() 输出： 10 输出： 70 60 50
4 使用as指定模块别名
在Python程序中，除了可以使用关键字“as”给函数指定简短而独一无二的别名外，还可以使用关键字“as”给模块文件指定一个别名。
def printinfo(arg1,*vartuple):
"显示任何传入的参数"
print("输出：") # 显示文本
print(arg1) # 显示参数arg1
for var in vartuple : # 遍历参数vartuple中的值
print(var) # 显示遍历到的值
return
import text as mm # 将函数printinfo()设置为别名“mm” mm.printinfo(10) # 相当于调用函数printinfo() mm.printinfo(70,60,50) # 相当于调用函数printinfo() 输出： 10 输出： 70 60 50
5 导入所有函数
在Python程序中，可以使用星号运算符“*”导入外部模块文件中的所有函数。
def printinfo(arg1,*vartuple):
"显示任何传入的参数"
print("输出：") # 显示文本
print(arg1) # 显示参数arg1
for var in vartuple : # 遍历参数vartuple中的值
print(var) # 显示遍历到的值
return
from text import * # 导入文件text.py中的所有函数 printinfo(10) # 调用函数printinfo() printinfo(70,60,50) # 调用函数printinfo() 输出： 10 输出： 70 60 50
6 pass 语句
函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误。
def myfunction: pass
9 技术解惑
10 课后练习
1 利用递归函数调用方式，将所输入的5个字符，以相反顺序显示出来。
s=input("输入一串字符: ")
s=list(s);
for i in range(0,int(len(s)/2)):
t=s[len(s)-i-1];
s[len(s) - i - 1]=s[i]
s[i]=t
print("".join(s))
输入一串字符: jkadsfhjk
kjhfsdakj
2 递归函数：自己调用自己
递归的特性：
1 ，必须有一个明确的结束条件（）
2 ，每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3 ，递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈stack这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用次数过多，会导致栈溢出）
def fun(age,rank): #age 年龄，rank 递归第几个人
if rank == 1:
return age
else:
return fun(age+2,rank-1)
print (fun(10,5))
18
3
num = list(input('输入一个最多5位的数字:'))
print(len(num))
num.reverse()
# 是python中列表的一个内置方法（也就是说，在字典，字符串或者元组中，是没有这个内置方法的），用于列表中数据的反转；
for i in range(len(num)):
print(num[i], end='')
输入一个最多5位的数字:5645
4
5465
4 判断一个5位数是不是回文数。
a = input("输入一串数字: ")
b = a[::-1] # a[::-1]翻转
if a == b:
print("%s 是回文"% a)
else:
print("%s 不是回文"% a)
输入一串数字: 546546
546546 不是回文
5 高阶函数：变量名可以指向函数名，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数
只需满足以下任意一个条件，既是高阶函数
1 接收一个或多个函数作为输入
2 return 返回另外一个函数
def get_abs(n):
if n < 0:
n = int(str(n).strip('-')) #Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
return n
def add(x,y,f):
return f(x) + f(y)
res = add(3,-6,get_abs) # get_abs 不加括号
print(res)
#####
8 面向对象
1 定义并使用类
1 定义类
class ClassName: 语句 class：是定义类的关键字。 ClassName：类的名称，Python语言规定，类的首字母大写。
2 类的基本用法
在Python程序，类只有被实例化后才能够被使用。类的实例化跟函数调用类似，只要使用类名加小括号的形式就可以实例化一个类。类实例化以后会生成该类的一个实例，一个类可以实例化成多个实例，实例与实例之间并不会相互影响，类实例化以后就可以直接使用了。
class Myclass : # 定义类
"this is a class"
myclass = Myclass() # 实例化类Myclass
print('输出类的说明：') # 显示文本信息
print(myclass.__doc__) # 显示属性值
print('显示类帮助信息：')
help(myclass)
输出类的说明：
this is a class
显示类帮助信息：
Help on Myclass in module __main__ object:
class Myclass(builtins.object)
| this is a class
|
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
2 类对象
Python程序中，类实例化化后就生成了一个对象。类对象支持两种操作，分别是属性引用和实例化。属性引用的使用方法和Python中所有的属性引用的方法一样，都是使用“obj.name”格式。在类对象被创建后，类命名空间中所有的命名都是有效属性名。
class Myclass : # 定义类
"""这是一个简单的类实例"""
i = 12345 # 设置变量i的初始值
def f(self): # 定义类方法f()
return 'hello world' # 显示文本
x = Myclass() # 实例化类
# 下面俩行代码分别访问类的属性和方法
print("类Myclass中的属性i为：",x.i)
print("类Myclass中的方法f输出为：",x.f())
类Myclass中的属性i为： 12345
类Myclass中的方法f输出为： hello world
3 类方法
1 定义并使用类方法
在Python程序中，可以使用关键字def在类的内部定义一个方法。在定义类的方法后，可以让类具有一定的功能。在类外部调用该类的方法时就可以完成相应的功能，或改变类的状态，或达到其他目的。
class SmplClass : # 定义类SmpClass
def info(self): # 定义类方法info()
print("我定义的类！") # 显示文本
def mycacl(self,x,y): # 定义类方法mycacl()
return x + y # 返回参数x和y的和
sc = SmplClass() # 实例化类
print('调用info方法的结果：')
sc.info() # 调用实例对象sc中的方法info()
print('调用mycacl方法的结果：')
print(sc.mycacl(3,4)) # 调用实例对象sc中的方法mycacl()
调用info方法的结果：
我定义的类！
调用mycacl方法的结果：
7
2 构造方法
在Python程序中，在定义类时可以定义一个特殊的构造方法，即init ()方法，注意init前后分别是两个下划线“_”。构造方法用于类实例化时初始化相关数据，如果在这个方法中有相关参数，则实例化时就必须提供。
class Complex : # 定义类
def __init__(self,realpart,imagpart): # 定义构造方法
self.r = realpart # 初始化构造方法参数
self.i = imagpart # 初始化构造方法参数
x = Complex(3.0,-4.5) # 实例化类
print(x.r,x.i) # 显示俩个方法参数
3.0 -4.5
class dog() :
"""小狗"""
def __init__(self,name,age):
self.n = name
self.a = age
def wang(self):
"""模拟狗叫"""
print(self.n.title() + "汪汪")
def shen(self):
"""伸舌头"""
print(self.n.title() + "伸舌头")
a = dog('tt',10)
a.wang()
a.shen()
Tt汪汪
Tt伸舌头
3 方法调用
方法调用就是调用创建的方法，在Python程序中，类中的方法既可以调用本类中的方法，也可以调用全局函数来实现相关功能。调用全局函数的方式和面向过程中的调用方式相同，而调用本类中的方法时应该使用如下所示的格式： self.方法名(参数列表)
def diao(x,y) :
return (abs(x),abs(y))
class Ant :
def __init__(self,x = 0,y = 0):
self.x = x
self.y = y
self.d_point()
def yi(self,x,y):
x,y = diao(x,y)
self.e_point(x,y)
self.d_point()
def e_point(self,x,y):
self.x += x
self.y += y
def d_point(self):
print("in :(%d,%d)"%(self.x,self.y))
ant_a = Ant()
ant_a.yi(2,7)
ant_a.yi(-5,6)
in :(0,0)
in :(2,7)
in :(7,13)
4 创建多个实例
在Python程序中，可以将类看做是创建实例的一个包含。只有在类中创建实例，这个类才变得有意义。 在Python程序中，可以按照需求根据类创建任意数量的实例。
class dog() :
"""小狗"""
def __init__(self,name,age): # 定义构造方法
self.n = name #
self.a = age #
def wang(self):
"""模拟狗叫"""
print(self.n.title() + "汪汪")
def shen(self):
"""伸舌头"""
print(self.n.title() + "伸舌头")
my_dog = dog('dagou',6)
your_dog = dog('xiaogou',3)
print("my dog's name is" + my_dog.n.title())
print("my dog's age is :" + str(my_dog.a))
my_dog.wang()
print("\n your dog's name is :" + your_dog.n.title())
print("your dog's age is :" + str(your_dog.a))
your_dog.wang()
my dog's name isDagou
my dog's age is :6
Dagou汪汪
your dog's name is :Xiaogou
your dog's age is :3
Xiaogou汪汪
5 使用私有方法
在Python程序中也有私有这一概念，与大多数的语言不同，一个 Python函数、方法或属性是私有还是公有，完全取决于它的名字。如果一个 Python 函数、类方法或属性的名字以两个下划线“”开始 （注意，不是结束），那么这个函数、方法或属性就是私有的，其它所有的方式都是公有的。当在类的内部调用私有成员时，可以用点“.”运算符实现，例如在类内的内部调用私有方法的语法格式如下所示。 slef.方法名
私有函数不可以从它们的模块外面调用
私有类方法不能从它们的类外面调用
私有属性不能从它们的类外面访问
class Site : # 定义类
def __init__(self,name,ur1): # 定义构造方法
self.name = name # 公共属性
self.__ur1 = ur1 # 私有属性
def who(self):
print('name :',self.name)
print('ur1 :',self.__ur1)
def __foo(self): # 定义私有方法
print('这是私有方法')
def foo(self): # 定义公共方法
print('这是公共方法')
self.__foo() # 内部调用
X = Site('菜鸟教程','www.toppr.net')
X.who()
X.foo()
# X.__foo() # 外部调用，代码报错
name : 菜鸟教程
ur1 : www.toppr.net
这是公共方法
这是私有方法
6 析构方法
在Python程序中，析构方法是del()，“del”前后分别有两个下划线“”。当使用内置方法del()删除对象时，会调用他本身的析构函数。另外当一个对象在某个作用域中调用完毕后，在跳出其作用域的同时析构函数也会被调用一次，这样可以使用析构方法是del__()释放内存空间。
class NewClass : # 类
num_count = 0 # 所有的实例都共享此变量，不能单独为每个实例分配
def __init__(self,name): # 定义构造方法
self.name = name # 实例属性
NewClass.num_count += 1 # 设置变量num_count值加1
print(name,NewClass.num_count)
def __del__(self): # 定义析构方法__del__
NewClass.num_count -= 1 # 设置变量值减1
print("Del",self.name,NewClass.num_count)
def test(self): # 定义方法test
print("aa")
aa = NewClass("hello") # 定义类NewClass的实例化对象aa
bb = NewClass("world") # 定义类NewClass的实例化对象bb
cc = NewClass("aaaaa") # 定义类NewClass的实例化对象cc
del aa # 调用析构
del bb # 调用析构
del cc # 调用析构
print("over")
hello 1
world 2
aaaaa 3
Del hello 2
Del world 1
Del aaaaa 0
over
7 静态方法和类方法
实例方法：在本书前面用到的所有类中的方法都是实例方法，其隐含调用参数是类的实例。 类方法：隐含调用的参数是类。在定义类方法时，应使用装饰器@classmethod进行修饰，并且必须有默认参数“cls”。 静态方法：没有隐含调用参数。类方法和静态方法的定义方式都与实例方法不同，它们的调用方式也不同。在定义静态方时，应该使用修饰符@staticmethod进行修饰，并且没有默认参数的。
class jing : # 类
def __init__(self,x = 0): # 定义构造方法
self.x = x # 设置属性
@staticmethod # 使用静态方法装饰器
def static_method(): # 定义静态类方法
print('此处调用了静态方法！')
## print(self.x)
@classmethod # 使用类方法装饰器
def class_method(cls): # 定义类方法，默认参数使cls
print('此处调用了类方法！')
jing.static_method() # 没有实例化类，通过类名调用类方法
jing.class_method() # 没有实例化类，通过类名调用类方法
dm = jing() # 实例化类
dm.static_method() # 通过类实例调用静态方法
dm.class_method() # 通过类实例调用类方法
此处调用了静态方法！
此处调用了类方法！
此处调用了静态方法！
此处调用了类方法！
8 类的专有方法
init：构造方法，在生成对象时调用。 del：析构方法，释放对象时使用。 repr：打印，转换。 setitem：按照索引赋值。 getitem：按照索引获取值。 len：获得长度。 cmp：比较运算。 call：函数调用。 add：加运算。 sub：减运算。 mul：乘运算。 div：除运算。 mod：求余运算。 pow：乘方。
4 类属性
1 认识属性
class dog() :
"""小狗"""
def __init__(self,name,age):
self.n = name
self.a = age
def wang(self):
"""模拟狗叫"""
print(self.n.title() + "汪汪")
def shen(self):
"""伸舌头"""
print(self.n.title() + "伸舌头")
my_dog = dog('dagou',6)
your_dog = dog('xiaogou',3)
print("my dog's name is" + my_dog.n.title())
print("my dog's age is :" + str(my_dog.a))
my_dog.wang()
print("\n your dog's name is :" + your_dog.n.title())
print("your dog's age is :" + str(your_dog.a))
your_dog.wang()
my dog's name isDagou
my dog's age is :6
Dagou汪汪
your dog's name is :Xiaogou
your dog's age is :3
Xiaogou汪汪
2 类属性和实例属性
实例属性：是同一个类的不同实例，其值是不相关联的，也不会互相影响的，定义时使用“self.属性名”的格式定义，调用时也使用这个格式调用。 类属性：是同一个类的所有实例所共有的，直接在类体中独立定义，引用时要使用“类名.类变量名”的格式来引用，只要是某个实例对其进行修改，就会影响其他的所有这个类的实例。
class X_Property : # 定义类
class_name = "X_Property" # 设置类的属性
def __init__(self,x = 0): # 构造方法
self.x = x # 设置实例属性
def class_info(self): # 定义方法class_info()输出信息
print('类变量值：',X_Property.class_name) # 输出类变量值
print('实例变量值：',self.x) # 输出实例变量值
def chng(self,x): # 定义方法chng()修改实例属性
self.x = x # 引用实例属性
def chng_cn(self,name): # 定义方法chng_cn()修改类属性
X_Property.class_name = name # 引用类属性
aaa = X_Property() # 实例化对象aaa
bbb = X_Property() # 实例化对象bbb
print('初始化俩个实例')
aaa.class_info() # 调用
bbb.class_info() # 调用
print('修改实例变量')
print('修改aaa实例变量')
aaa.chng(3) # 修改对象aaa的实例变量
aaa.class_info() # 调用
bbb.class_info() # 调用
print('修改bbb实例变量')
bbb.chng(10) # 修改bbb实例变量
aaa.class_info() # 调用
bbb.class_info() # 调用
print('修改类变量')
print('修改aaa类变量')
aaa.chng_cn('aaa') # 修改aaa类变量
aaa.class_info() # 调用
bbb.class_info() # 调用
print('修改bbb类变量')
bbb.chng_cn('bbb') # 修改bbb类变量
aaa.class_info() # 调用
bbb.class_info() # 调用
初始化俩个实例
类变量值： X_Property
实例变量值： 0
类变量值： X_Property
实例变量值： 0
修改实例变量
修改aaa实例变量
类变量值： X_Property
实例变量值： 3
类变量值： X_Property
实例变量值： 0
修改bbb实例变量
类变量值： X_Property
实例变量值： 3
类变量值： X_Property
实例变量值： 10
修改类变量
修改aaa类变量
类变量值： aaa
实例变量值： 3
类变量值： aaa
实例变量值： 10
修改bbb类变量
类变量值： bbb
实例变量值： 3
类变量值： bbb
实例变量值： 10
3 设置属性的默认值
在Python程序中，类中的每个属性都必须有初始值，并且有时可以在方法init ()中指定某个属性的初始值是0或空字符串。如果设置了某个属性的初始值，就无需在属性中包含为其提供初始值的形参。假设有这么一个场景，年底将至，作者想换辆新车，初步中意车型是奔驰E级。
class Car() :
"""奔驰，我的最爱"""
def __init__(self,manufacturer,model,year):
"""初始化操作，创建描述汽车的属性"""
self.manufacturer = manufacturer
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
"""返回描述信息"""
long_name = str(self.year) + ' ' + self.manufacturer + ' ' +self.model
return long_name.title()
def read_odometer(self):
"""行驶里程"""
print("this is a new car :" + str(self.odometer_reading))
my_new_car = Car('Benz','E3ooL',2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()
2016 Benz E3Ool
this is a new car :0
4 修改属性的值
1 直接通过实例进行修改 在Python程序中，可以直接通过实例的方式修改一个属性的值。
my_new_car = Car('Benz','E3ooL',2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 12
my_new_car.read_odometer()
2016 Benz E3Ool
this is a new car :12
2 自定义方法修改 在Python程序中，可以自定义编写一个专有方法来修改某个属性的值。这时可以无需直接访问属性，而只是将值传递给自定义编写的方法，并在这个方法内部进行修改即刻。
通过自定义方法update_odometer()修改行驶里程
def update_odometer(self,mileage):
"""修改行驶里程"""
if mileage >= self.odometer_reading :
self.odometer_reading = mileage
else:
print("this is not right")
my_new_car = Car('Benz','E3ooL',2016)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(15)
my_new_car.read_odometer()
2016 Benz E3Ool
this is a new car :15
通过递增值修改行驶里程
def increment_odometer(self,miles):
"""通过递增的方式修改行驶里程"""
self.odometer_reading += miles
my_new_car = Car('Benz','E3ooL',2016)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(15)
my_new_car.read_odometer()
my_new_car.increment_odometer(2000)
my_new_car.read_odometer()
2016 Benz E3Ool
this is a new car :15
this is a new car :2015
5 使用私有属性
只要在属性名或方法名前加上两个下划线 “”，那么这个属性或方法就会为私有的了。在Python程序中，私有属性不能在类的外部被使用或直接访问。当在类的内部使用私有属性时，需要通过“self.属性名”的格式使用。
class Person() : # 定义类Person()
def __init__(self):
self.__name = 'haha' # 设置私有属性值是‘haha’
self.age = 20 # 设置属性age值是22
def get_name(self): # 定义方法
return self.__name # 返回私有属性
def get_age(self): # 定义方法
return self.age
person = Person() # 定义类对象实例
print(person.get_age()) # 显示属性值
print(person.get_name()) # 显示私有属性值
20
haha
5 继承
1 定义子类
class ClassName1(ClassName2): 语句 在上述语法格式中，“ClassName1”表示子类（派生类）名，“ClassName2”表示基类（父类）名。如果在基类中有一个方法名，而在子类使用时未指定，Python会从左到右进行搜索。也就是说，当方法在子类中未找到时，从左到右查找基类中是否包含方法。另外，基类名ClassName2必须与子类在同一个作用域内定义。
class Car() :
"""汽车之家"""
def __init__(self,manufacturer,model,year):
"""初始化操作，建立描述汽车的属性"""
self.manufacturer = manufacturer
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
"""返回描述信息"""
long_name = str(self.year) + ' ' + self.manufacturer + ' ' + self.model
return long_name.title()
def read_odometer(self):
"""行驶里程"""
print("显示里程是" + str(self.odometer_reading))
class Bmw(Car):
"""这是一个子类Bmw,基类是Car"""
def __init__(self,manufacturer,model,year):
super().__init__(manufacturer,model,year)
my_tesla = Bmw('宝马','535li','2017')
print(my_tesla.get_descriptive_name())
2017 宝马 535Li
2 在子类中定义方法和属性
在Python程序中，子类除了可以继承使用父类中的属性和方法外，子类还可以单独定义自己的属性和方法。
class Car() :
"""汽车之家"""
def __init__(self,manufacturer,model,year):
"""初始化操作，建立描述汽车的属性"""
self.manufacturer = manufacturer
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
"""返回描述信息"""
long_name = str(self.year) + ' ' + self.manufacturer + ' ' + self.model
return long_name.title()
def read_odometer(self):
"""行驶里程"""
print("显示里程是" + str(self.odometer_reading))
class Bmw(Car):
"""这是一个子类Bmw,基类是Car"""
def __init__(self,manufacturer,model,year):
super().__init__(manufacturer,model,year)
self.batttery_size = '3T'
def motor(self):
"""输出发动机参数"""
print("发动机是：" + str(self.batttery_size))
my_tesla = Bmw('宝马','535li','2017')
print(my_tesla.get_descriptive_name())
my_tesla.motor()
2017 宝马 535Li
发动机是：3T
3 子类可以继续派生新类
在Python程序中，根据项目情况的需要，可以基于一个子类继续创建一个子类。这种情况是非常普遍的，例如在使用代码模拟实物时，开发者可能会发现需要给类添加越来越多的细节，这样随着属性和方法个数的增多，代码也变得更加复杂，十分不利于阅读和后期维护。
class Bmw(Car):
"""这是一个子类Bmw,基类是Car"""
def __init__(self,manufacturer,model,year):
super().__init__(manufacturer,model,year)
self.Motor = Motor()
class Motor(Bmw) :
"""类Motor是类Car的子类"""
def __init__(self,Motor_size = 60):
"""初始化发动机属性"""
self.Motor_size = Motor_size
def describe_motor(self):
"""输出发动机参数"""
print("发动机是：" + str(self.Motor_size))
my_tesla = Bmw('宝马','535li','2017')
print(my_tesla.get_descriptive_name())
my_tesla.Motor.describe_motor()
2017 宝马 535Li
发动机是：60
4 私有属性和私有方法
在Python程序中，当子类继承了父类之后，虽然子类具有了父类的属性与方法，但是不能继承父类中的私有属性和私有方法（属性名或方法名的前缀为两个下画线），在子类中还可以使用重载的方式来修改父类的方法，以实现与父类不同的行为表现或能力。
class A :
def __init__(self):
self.__name = "yy"
self.age = 12
class B(A) :
def sayName(self):
print(self.__name)
b= B()
b.sayName()
print(self.__name)
AttributeError: 'B' object has no attribute '_B__name'
5 多重继承
class DerivedClassName(Base1, Base2, Base3): 在上述语法格式中，“DerivedClassName”表示子类名，小括号中的“Base1”、“Base2”和“Base3” 表示多个父类名。在Python多重继承程序中，继承顺序是一个很重要的要素。如果继承的多个父类中有相同的方法名，但在类中使用时未指定父类名，则Python解释器将从左至右搜索，即调用先继承的类中的同名方法。
class PrntOne :
namea = 'PrntOne'
def set_value(self,a):
self.a = a
def set_namea(self,namea):
PrntOne.namea = namea
def info(self):
print('PrntOne:%s,%s'%(PrntOne.namea,self.a))
class PrntSecond :
nameb = 'PrntSecond'
def set_nameb(self,nameb):
PrntSecond.nameb = nameb
def info(self):
print('PrntSecond:%s'%(PrntSecond.nameb,))
class Sub(PrntOne,PrntSecond):
pass
class Sub2(PrntSecond,PrntOne):
pass
class Sub3(PrntOne,PrntSecond):
def info(self):
PrntOne.info(self)
PrntSecond.info(self)
print('使用第一个子类')
sub = Sub()
sub.set_value('11111')
sub.info()
sub.set_nameb('22222')
sub.info()
print('使用第二个子类')
sub2 = Sub2()
sub2.set_value('33333')
sub2.info()
sub2.set_nameb('44444')
sub2.info()
print('使用第三个子类')
sub3 = Sub3()
sub3.set_value('555555')
sub3.info()
sub3.set_nameb('66666')
sub3.info()
使用第一个子类
PrntOne:PrntOne,11111
PrntOne:PrntOne,11111
使用第二个子类
PrntSecond:22222
PrntSecond:44444
使用第三个子类
PrntOne:PrntOne,555555
PrntSecond:44444
PrntOne:PrntOne,555555
PrntSecond:66666
6 方法重写
方法重写也叫方法重载，在Python程序中，当子类在使用父类中的方法时，如果发现父类中的方法不符合子类的需求，可以对父类中的方法进行重写。在重写时需要先在子类中定义一个这样的方法，与要重写的父类中的方法同名，这样Python程序将不会再使用父类中的这个方法，而只使用在子类中定义的这个和父类中重名的方法（重写方法）。
class Wai : # 定义父类Wai
def __init__(self,x=0,y=0,color='black'):
self.x = x
self.y = y
self.color = color
def haijun(self,x,y): # 定义海军方法haijun()
self.x = x
self.y = y
print('鱼雷。。。')
self.info()
def info(self):
print('定位目标：(%d,%d)'%(self.x,self.y))
def gongji(self): # 父类中的方法gongji()
print("导弹发射")
class FlyWai(Wai):
def gongji(self): # 子类中的方法gongji()
print("飞船拦截")
def fly(self,x,y):
print('火箭军。。。')
self.x = x
self.y = y
wai = Wai()
wai.info()
flyWai = FlyWai(color= 'red' )
flyWai.haijun(100,200)
flyWai.fly(12,15)
flyWai.gongji()
定位目标：(0,0)
鱼雷。。。
定位目标：(100,200)
火箭军。。。
飞船拦截
7 技术解惑
9 二进制运算
print(bin(128)) # 十进制转二进制 0b10000000
a = 60
b = 13
print(f"a = {a}, a的二进制形式为：{bin(a)}")
print(f"b = {b}, b的二进制形式为：{bin(b)}")
print(f'a & b = {a & b}, 二进制形式为：{bin(a & b)}') # 与运算，位相乘
print(f'a | b = {a | b}, 二进制形式为：{bin(a | b)}') # 或运算，位相加
print(f'a ^ b = {a ^ b}, 二进制形式为：{bin(a ^ b)}') # 异或运算，位相减
print(f'-a = {~a }, 二进制形式为：{bin(~a)}') # 按位取反，~X =-(X+1)
print(f'a << 2 = {a << 2}, 二进制形式为：{bin(a << 2)}') # 左移运算符，高位丢弃，地位补0
print(f'a >> 2 = {a >> 2}, 二进制形式为：{bin(a >> 2)}') # 右移运算符
a = 60, a的二进制形式为：0b111100 # 0011 1100
b = 13, b的二进制形式为：0b1101 # 0000 1101
a & b = 12, 二进制形式为：0b1100 # 0000 1100
a | b = 61, 二进制形式为：0b111101 # 0011 1101
a ^ b = 49, 二进制形式为：0b110001 # 0011 0001
-a = -61, 二进制形式为：-0b111101 # 0011 1101
a << 2 = 240, 二进制形式为：0b11110000 # 1111 0000
a >> 2 = 15, 二进制形式为：0b1111 # 0000 1111
10 文件操作处理
1 使用open()函数打开文件
1 open()函数
open(filename, mode='r', buffering=-l, encoding=None, errors=None, newline=None,closefd=True, opener=None)
•filename：表示要打开的文件名。
•mode：可选参数，文件打开模式。这个参数是非强制的，默认文件访问模式为只读(r)。
•bufsize：可选参数，缓冲区大小。
•encoding：文件编码类型。
•errors：编码错误处理方法。
•newline：控制通用换行符模式的行为。
•closefd：控制在关闭文件时是否彻底关闭文件。
#!D:\pycharm\xx\
# fo = open("456.txt", "wb") # 方法一 文件和程序在同一级文件夹
# fo = open(r"C:\Users\SYL\Desktop\labels.txt","wb") # 方法二 指定确定的文件地址
fo = open(r"C:/Users/SYL/Desktop/labels.txt","wb") # 对比方法二 “\” 变为“/”
print ("文件名: ", fo.name)
print ("是否已关闭 : ", fo.closed)
print ("访问模式 : ", fo.mode)
D:\pycharm\xx\venv\Scripts\python.exe D:/pycharm/xx/zuoye1.py
文件名: C:/Users/SYL/Desktop/labels.txt
是否已关闭 : False
访问模式 : wb
2 文件打开模式
r # 以只读模式打开文件 rb # 以二进制格式打开一个文件只用于读 r+ # 打开一个文件用于读写 rb+ # 以二进制格式打开一个文件用于读写 w # 打开一个文件只用于写入，写模式，存在先清空覆盖，不存在创建新文件 wb # 以二进制格式打开一个文件只用于写入 w+ # 打开一个文件用于读写 wb+ # 以二进制格式打开一个文件用于读写 a # 打开一个文件用于追加 （日志的时候可用） ab # 以二进制格式打开一个文件用于追加 a+ # 打开一个文件用于读写 ab+ # 以二进制格式打开一个文件用于追加 x # 创建文件，打开写 文件在会报错，不会清空 t # 默认文本 b # 二进制模式 + # 读和写
2 使用File操作文件
1 File对象介绍
•file.closed：返回true如果文件已被关闭，否则返回false。
•file.mode ：返回被打开文件的访问模式。
•file.name ：返回文件的名称。
2 使用close()方法关闭文件
在Python程序中，方法close()用于关闭一个已经打开的文件，关闭后的文件不能再进行读写操作， 否则会触发ValueError 错误。在程序中可以多次调用close()方法，当 file对象被引用到操作另外一个文件时，Python会自动关闭之前的file对象。及时使用方法关闭文件是一个好的编程习惯，使用close()方法的语法格式如下所示。
fileObject.close();
3 使用方法flush()把缓存里的写入的数据强制刷新硬盘
在Python程序中，方法flush()的功能是刷新缓冲区，即将缓冲区中的数据立刻写入文件，同时清空缓冲区。在一般情况下，文件关闭后会自动刷新缓冲区，但时有时需要在关闭之前刷新它，这时就可以使用方法flush()实现。使用方法flush()的语法格式如下所示。
fileObject.flush();
r = open('flush_test.txt','a')
r.write('hello world \n')
r.write('nice to meet you\n')
r.flush()
r.write('ok')
4 使用方法fileno()
在Python程序中，方法fileno()的功能是返回一个整型的文件描述符(file descriptor FD 整型)，可以用于底层操作系统的I/O操作。使用方法fileno()的语法格式如下所示。
fileObject.fileno();
5 使用方法isatty()返回文件是否是interactive数据流
比如是个命令行终端，在unix系统，一切皆文件
在Python程序中，方法isatty()的功能是检测某文件是否连接到一个终端设备，如果是则返回True，否则返回False。使用方法isatty()的语法格式如下所示。
fileObject.isatty();
6 使用方法next()
在Python程序中，File 3对象不支持方法next()。在Python 3程序中，内置函数next()通过迭代器调用方法next()返回下一项。在循环中，方法next()会在每次循环中调用，该方法返回文件的下一行。如果到达结尾(EOF)，则触发StopIteration异常。使用方法next()的语法格式如下所示。
next(iterator[,default])
7 使用方法read()读指定长度的内容
f.read(1024) 读1024字节
Python程序中，使用方法read()的语法格式如下所示。
file.read([size])； 默认读整个文本
fo = open(r"C:/Users/SYL/Desktop/labels.txt")
print ("文件名: ", fo.name)
print ("是否已关闭 : ", fo.closed)
print ("访问模式 : ", fo.mode)
# print('读取 ：',fo.read())
print('读取 ：',fo.read(6))
文件名: C:/Users/SYL/Desktop/labels.txt
是否已关闭 : False
访问模式 : r
# 读取 ： hello world
读取 ： hello
8 使用方法readline()读一行
在Python程序中，使用方法readline()的语法格式如下所示。
fileObject.readline(size);
f = open('my_first.file.txt')
# data = f.read() # 读所有
# print(data)
#
# data = f.read(2)
# print(data)
print(f.readline())
print(f.readline())
for line in f:
if 'cc' in line:
print(line)
9 使用方法readlines()都所有，每行列表形式返回
在Python程序中，使用方法readlines()的语法格式如下所示。
fileObject.readlines( sizehint );
10 使用方法seek()把光标移到指定位置
在Python程序中，方法seek()没有返回值，功能是移动文件读取指针到指定位置。使用方法seek()的语法格式如下所示。
fileObject.seek(offset[, whence])
f = open('my_first.file.txt')
print(f.readline())
print(f.readline())
f.seek(0)
print(f.readline())
for line in f:
if 'cc' in line:
print(line)
11 使用方法tell()返回当前光标位置
在Python程序中，方法tell()没有参数，功能是获取文件的当前位置，即文件指针当前位置。使用方法tell()的语法格式如下所示。
fileObject.tell(offset[, whence])
r = open('flush_test.txt','a')
r.write('hello world \n')
r.write('nice to meet you\n')
r.flush()
r.write('ok')
print(r.tell())
12 使用方法truncate()截断文件
f.truncate(100)，从文件开头截断100个字符，后边的都扔掉
在Python程序中，使用方法truncate()的语法格式如下所示。
fileObject.truncate( [ size ])
r = open('flush_test.txt','a')
r.write('hello world \n')
r.write('nice to meet you\n')
r.flush()
r.write('ok')
print(r.tell())
print(r.truncate())
print(r.truncate(10))
234
234
10
文件：hello worl
r = open('flush_test.txt','a')
r.write('hello world \n')
r.write('nice to meet you\n')
r.flush()
r.write('ok')
print(r.tell())
# print(r.truncate())
# print(r.truncate(10))
print(r.seek(15))
print(r.truncate())
78
15
15
文件：hello worlhello
13 使用方法writelines()把一个列表写入，每个元素是一行
在Python程序中，使用方法writelines()的语法格式如下所示。
fileObject.writelines( [ str ])
14 使用方法closed()查看文件是否已关闭
15 使用方法ending()返回文件的编码
16 mode返回当前文件模式
17 name返回文件名
18 readable文件是否可读
19 seekable读文件光标是否可移动
20 writable是否可写
21 write写内容
fo = open("456.txt", "w")
fo.write('nice to meet you')
fo.write('\nthank you')
nice to meet you
thank you
import random
import string
name = ['aa','bb','cc','dd']
f = open("my_first.file.txt", "w")
for i in name:
passwd = random.sample(string.ascii_letters + string.digits,8)
line = f"{i}:{''.join(passwd)}\n"
f.write(line)
f.close()
aa:59VmkDcB
bb:F0Xf7Mv5
cc:fs96Qy5h
dd:81l0VeDv
22 修改文件内容
1 先把文件内容加载到内存
2 替换要改的部分
3 清空源文件内容
4 把新的内容写回去
f = open('my_first.file.txt','r+')
data = f.read() # 加载
data_new = data.replace("bb","ff") # 替换
f.seek(0)
f.truncate() # 清空
f.write(data_new) # 写入
f.close()
3 使用OS对象
1 OS对象介绍
2 使用方法access()
3 使用方法chdir()
4 使用方法chmod()
5 打开，写入和关闭
6 打开，读取和关闭
7 创建目录
8 获取目录下的信息
9 修改目录
10 删除目录
4 其他常见的文件操作
1 使用fileinputmok
2 批量获取文件名
5 技术解惑
1 注意包含文件的具体范围
2 4点注意事项
6 课后练习
模块
1 string
import string
print(string.ascii_lowercase)
print(string.ascii_uppercase)
print(string.ascii_letters)
print(string.digits)
print(string.hexdigits)
print(string.octdigits)
print(string.punctuation)
print(string.printable)
string.ascii_lowercase : abcdefghijklmnopqrstuvwxyz
string.ascii_uppercase : ABCDEFGHIJKLMNOPQRSTUVWXYZ
string.ascii_letters : abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
string.digits : 0123456789
string.hexdigits : 0123456789abcdefABCDEF
string.octdigits : 01234567
string.punctuation : !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
string.printable : 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
日期和时间
Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。时间间隔是以秒为单位的浮点小数。每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。Python 的 time 模块下有很多函数可以转换常见日期格式。
如函数time.time()用于获取当前时间戳, 如下实例:
#!/usr/bin/python # -*- coding: UTF-8 -*- import time # 引入time模块 ticks = time.time() print "当前时间戳为:", ticks 运行结果 当前时间戳为: 1459994552.51
时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
| 序号 | 字段 | 值 |
|---|---|---|
| 0 | 4位数年 | 2008 |
| 1 | 月 | 1 到 12 |
| 2 | 日 | 1到31 |
| 3 | 小时 | 0到23 |
| 4 | 分钟 | 0到59 |
| 5 | 秒 | 0到61 (60或61 是闰秒) |
| 6 | 一周的第几日 | 0到6 (0是周一) |
| 7 | 一年的第几日 | 1到366 (儒略历) |
| 8 | 夏令时 | -1, 0, 1, -1是决定是否为夏令时的旗帜 |
什么是时间元组？很多Python函数用一个元组装起来的9组数字处理时间:
上述也就是struct_time元组。这种结构具有如下属性：
| 序号 | 属性 | 值 |
|---|---|---|
| 0 | tm_year | 2008 |
| 1 | tm_mon | 1 到 12 |
| 2 | tm_mday | 1 到 31 |
| 3 | tm_hour | 0 到 23 |
| 4 | tm_min | 0 到 59 |
| 5 | tm_sec | 0 到 61 (60或61 是闰秒) |
| 6 | tm_wday | 0到6 (0是周一) |
| 7 | tm_yday | 1 到 366(儒略历) |
| 8 | tm_isdst | -1, 0, 1, -1是决定是否为夏令时的旗帜 |
获取当前时间
从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。
实例(Python 2.0+)
#!/usr/bin/python
-- coding: UTF-8 --
import time
localtime = time.localtime(time.time())
print "本地时间为 :", localtime
以上实例输出结果：
本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)
获取格式化的时间
你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
实例(Python 2.0+)
#!/usr/bin/python
-- coding: UTF-8 --
import time
ocaltime = time.asctime( time.localtime(time.time()) )
print "本地时间为 :", localtime
以上实例输出结果：
本地时间为 : Thu Apr 7 10:05:21 2016
格式化日期
我们可以使用 time 模块的 strftime 方法来格式化日期，：
time.strftime(format[, t])
实例演示：
实例(Python 2.0+)
#!/usr/bin/python
-- coding: UTF-8 --
import time
格式化成2016-03-20 11:45:39形式
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
格式化成Sat Mar 28 22:24:24 2016形式
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
将格式字符串转换为时间戳 a = "Sat Mar 28 22:24:24 2016"
print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
以上实例输出结果：
2016-04-07 10:25:09 Thu Apr 07 10:25:09 2016 1459175064.0
python中时间日期格式化符号：
-
%y 两位数的年份表示（00-99）
-
%Y 四位数的年份表示（000-9999）
-
%m 月份（01-12）
-
%d 月内中的一天（0-31）
-
%H 24小时制小时数（0-23）
-
%I 12小时制小时数（01-12）
-
%M 分钟数（00-59）
-
%S 秒（00-59）
-
%a 本地简化星期名称
-
%A 本地完整星期名称
-
%b 本地简化的月份名称
-
%B 本地完整的月份名称
-
%c 本地相应的日期表示和时间表示
-
%j 年内的一天（001-366）
-
%p 本地A.M.或P.M.的等价符
-
%U 一年中的星期数（00-53）星期天为星期的开始
-
%w 星期（0-6），星期天为星期的开始
-
%W 一年中的星期数（00-53）星期一为星期的开始
-
%x 本地相应的日期表示
-
%X 本地相应的时间表示
-
%Z 当前时区的名称
-
%% %号本身
获取某月日历
Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
实例(Python 2.0+)
#!/usr/bin/python
-- coding: UTF-8 --
import calendar
cal = calendar.month(2016, 1)
print "以下输出2016年1月份的日历:"
print cal
以上实例输出结果：
以下输出2016年1月份的日历:
January 2016
Mo Tu We Th Fr Sa Su
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
Time 模块
Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：
| 序号 | 函数及描述 |
|---|---|
| 1 | time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。 |
| 2 | [time.asctime(tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。 |
| 3 | time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。 |
| 4 | [time.ctime(secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime() |
| 5 | [time.gmtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0 |
| 6 | [time.localtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。 |
| 7 | time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。 |
| 8 | time.sleep(secs) 推迟调用线程的运行，secs指秒数。 |
| 9 | [time.strftime(fmt,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。 |
| 10 | time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据fmt的格式把一个时间字符串解析为时间元组。 |
| 11 | time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。 |
| 12 | time.tzset() 根据环境变量TZ重新初始化时间相关设置。 |
Time模块包含了以下2个非常重要的属性：
| 序号 | 属性及描述 |
|---|---|
| 1 | time.timezone 属性 time.timezone 是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲<=0大部分欧洲，亚洲，非洲）。 |
| 2 | time.tzname 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。 |
日历（Calendar）模块
此模块的函数都是日历相关的，例如打印某月的字符月历。
星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：
| 序号 | 函数及描述 |
|---|---|
| 1 | *calendar.calendar(year,w=2,l=1,c=6)** 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21 W+18+2* C。l是每星期行数。 |
| 2 | calendar.firstweekday( ) 返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一。 |
| 3 | calendar.isleap(year) 是闰年返回 True，否则为 False。>>> import calendar >>> print(calendar.isleap(2000)) True >>> print(calendar.isleap(1900)) False |
| 4 | calendar.leapdays(y1,y2) 返回在Y1，Y2两年之间的闰年总数。 |
| 5 | *calendar.month(year,month,w=2,l=1)** 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7 w+6。l是每星期的行数。 |
| 6 | calendar.monthcalendar(year,month) 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。 |
| 7 | calendar.monthrange(year,month) 返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。 |
| 8 | calendar.prcal(year,w=2,l=1,c=6) 相当于 print calendar.calendar(year,w=2,l=1,c=6)。 |
| 9 | calendar.prmonth(year,month,w=2,l=1) 相当于 print calendar.month(year,month,w=2,l=1) 。 |
| 10 | calendar.setfirstweekday(weekday) 设置每周的起始日期码。0（星期一）到6（星期日）。 |
| 11 | calendar.timegm(tupletime) 和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。 |
| 12 | calendar.weekday(year,month,day) 返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。 |
扫一扫
289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
