函数：
基础：
#基本语法
def <函数名>(<参数0个或多个>):
<函数体>
return <返回值>
如果未设置return ，默认返回None
#查看函数
dir(_builtins_)
#基础使用
def helloworld():
print('调用函数')
helloworld() #调用
print('调用完毕')
函数名注意事项：
- 关键字不能作为函数名字
- 函数名中不能存在空格
- 函数名的首字母必须是大小写字母或者下划线
- 函数名的其余字母可以使用字母、数字以及下划线
- 不同函数名大小写不同的时候为不同函数
- 常用的命名方式：字母＋下划线+字母
传参：
#自定义函数传参
def test(name,age):
print("姓名%s,年龄%s"%(name,age))
test('程序员',20) #传参位置不能打乱
test('程序员',age=20) #关键字参数，部分指定时，左边可以不指定，从右边指定开始
#减少因为参数位置和类型不一致的报错
#设置默认值
def test(name='程序员',age=18):
print("姓名%s,年龄%s"%(name,age))
test() ##函数默认输入一个值或者未输入的情况下，赋值
#传递任意数量的参数值
*函数名([param1,param2,…]paramX)
带“*”的paramX参数，可以以接收任意数量的值
自定义函数只能有一个带"*"的参数，只能放置最右边的参数中否则自定义函数执行时报错
def test(name,*attributes):
print(name)
print(type(attributes))
test('11','22','33','44')
#传递任意数量的键值对
函数名([param1,param2,…]**paramX)
def test(name,**attributes):
print(name)
print(type(attributes))
return attributes
test('兔子',color='白色',shape='圆形',)
return语句：
def get_sum(a,b):
sum = a + b
print('调用了这个函数')
return sum
print('完成了') #return 后面的语句不会执行
s = get_sum(1,2)
print(s)
def get_data():
a = 1
b = 2
c = 3
d = 4
return a,b,c,d #可以返回多个值，多个值放在元组中
print('返回值的类型:',type(get_data()))
print('返回值:',get_data())作用域：
num = 5 #全局变量
def sum():
k=2 #局部变量
global num #声明，修改全局变量
匿名函数：
#lambda表达式
作用：
1 常用于数据筛选
2 解决数据复杂繁琐的问题
3 代码简洁
4 优化代码
m = int(input('请输入一个数字:'))#m为输入的值
a = lambda x : x * x #使用变量a来构成一个表达式
print('返回值为：',a(m))
my_list = [1,4,6,9,12,23,25,28,36,38,41,56,63,77,88,99]
print(list(filter(lambda x : x % 2 == 0,my_list)))
#filter函数：过滤作用基础函数：
#filter(函数,可迭代对象) 数据筛选和过滤
def test(x):
if x % 2 == 0:
return x
my_list = [1,2,3,4,5,6]
print(filter(test,my_list))#只需要些函数名即可，不用加参数
#map(函数，可迭代对象) 数据的处理
def test(x):
if x.islower():
return x.upper()
else:
return x
my_list = ['d','o','t','C','p','P']
print(list(map(test,my_list))) #['D', 'O', 'T', 'C', 'P', 'P']
#reduce(函数, 可迭代对象[, 初始值]) 数据聚合
from functools import reduce#reduce函数在functools模块中定义，需要引入
def test(x,y):
return x * y
my_list = [1,2,3,4]
print(reduce(test,my_list))递归函数：
m = int(input('输入一个数字：'))
def test(x):
x += 2
if x <100:
test(x)
else:
print('最后的x为：',x)
test(m)内置函数：
| 函数名 | 方法说明 |
| abs() | 绝对值 |
| bin() | 二进制 |
| bool() | 布尔值 |
| chr() | 用一个范围在256内的整数作参数，返回一个对应的字符 |
| cmp(x,y) | 用于比较，前者大于后者返回1，相等返回0，小于后者返回-1 |
| compile() | 将字符串便以为字节代码 |
| complex() | 创建一个复数 |
| dict() | 创建字典 |
| divmod(x,y) | 返回一组值，前者为x和y的商，后者为余数 |
| enumerate() | 返回序列中元素及其索引值，使用for循环可依次输出。 |
| eval() | 返回字符串表达式的值 |
| file() | 创建一个 file 对象 |
| filter() | 过滤函数 |
| float() | 把整数和字符串转换成浮点数 |
| format() | 格式化函数 |
| getattr() | 一个对象属性值 |
| globals() | 全局变量 |
| hash() | 返回一个对象的哈希值 |
| help() | 查看函数或者模块的功能 |
| hex() | 将10进制整数转换成16进制 |
| id() | 返回一个对象在内存中的地址 |
| input() | 标准输入 |
| isinstance() | 判断一个对象是否为已知的类型 |
| int() | 把字符串或数字转换为整型 |
| len() | 返回序列的长度 |
| list() | 把其他数据类型转换为列表 |
| locals() | 返回当前位置的所有局部变量 |
| long() | 把一个数字或字符串转换为长整型 |
| map() | 映射函数 |
| max() | 返回最大值 |
| min() | 返回最小值 |
| next() | 返回迭代对象的下一项 |
| oct() | 整数转换八进制数 |
| pow(x,y) | 返回x的y次方 |
| print() | 输出 |
| range() | 创建整数序列 |
| reduce() | 聚合函数 |
| reload() | 重载模块 |
| reverse() | 逆序 |
| round() | 对浮点数四舍五入 |
| set() | 创建集合 |
| sorted() | 排序 |
| sum() | 求和 |
| zip() | 将可迭代的多个对象中根据对应关系组合在一个元组中 |
闭包函数：
j = 5 #全局变量
def sum():
k=2 #闭包变量
def sum():
i=k+j #局部变量
return i
return sum()扩展：
import decimal
num=decimal.Decimal('0.12')
num1=decimal.Decimal('0.12')
print(num+num1)面向对象：
面向对象编程有三大特点：封装、继承和多态
基础（类）：
#基本语法结构
class Name: #使用class定义类，Name是类名，一般首字母大写
'''类文档'''
content
#例子：
class School:#这种方式我们就定义了一个类，如果我们要调用这个类
'''定义一个学校类'''
def __init__(self):
print('这里是__init()__方法')
def __judge__(self):
print('判断这个方法是否被调用')
school = School()
#__init__()方法属于构造方法，每次调用School类都会使用__init__方法，参数传递也是在__init__方法里
#__init__方法中必须包含一个self参数，也必须是第一个参数，
#参数是指向这个实例本身的，可访问School类中存在的属性和方法
class GetAge:
def __init__(self,name,age):
self.name = name
self.age = age
print('%s的年龄为%d'%(name,age))
GetAge('小明',18) #传递参数类的方法：
class Library:
def __init__(self,name,id,age):
self.name = name
self.id = id
self.age =age
def borrow(self,bookname):
self.bookname = bookname
print('%s借阅了书籍--%s'%(self.name,self.bookname))
print('借阅者学号为%d,年龄为%s'%(self.id,self.age))
print('借书成功！')
xiaoming = Library('小明',1001,20)
xiaoming.borrow('Python教程')
class BookStore:
def __init__(self,bookname,bookcount):
self.bookname = bookname
self.bookcount = bookcount
def sell(self):
self.bookcount -= 1
print('%s现在有%s本'%(self.bookname,self.bookcount))
def buy(self):
self.bookcount += 10
print('%s现在有%s本' % (self.bookname, self.bookcount))
own = BookStore('Python学习教程',100)
own.sell()
own.buy()
own.sell()继承示例：
#继承：子继承父
class Base:#定义一个名为Base的父类
def __init__(self,name,age,id):
self.name = name
self.age = age
self.id = id
print('继承了Base这个类')
print('我的名字:',self.name)
print('我的年龄:',self.age)
print('我的学号:',self.id)
def goto_school(self):
print(self.name,'正在使用Base类中的goto_school方法去上学')
class Student(Base):#继承父类的时候会继承父类中的所有方法
pass
xiaoming = Student('小明',20,1001)
xiaoming.goto_school()重写示例：
#重写：基于继承的一种方法，如果不想要从父类中继承来的属性或者行为，可以在子类中进行方法的重写
class Base:#定义一个父类
def __init__(self,name):
self.name = name
print('继承了Base')
def eat_dinner(self):
print(self.name,'晚饭吃火锅')
class Student(Base):#继承父类的时候会继承父类中的所有方法
def eat_dinner(self):
print(self.name,'晚饭吃自助餐')
xiaoming = Student('小明')
xiaoming.eat_dinner()多态示例：
#多态：继承和重写两种方式的结合，通过多态我们可以写出各种各样的程序
class Base:
def __init__(self,name):
self.name =name
print('%s会读书'%self.name)
def reading(self):
print('%s在读语文书'%self.name)
class Inherit_One(Base):
def reading(self):
print('%s在读英语书'%self.name)
class Inherit_Two(Base):
def reading(self):
print('%s在看漫画书'%self.name)
a = Base('a')
a.reading()
b = Inherit_One('b')
b.reading()
c = Inherit_Two('c')
c.reading()模块开发：
模块分类：
- 系统库中存在的模块
- 第三方模块
- 自定义模块
引入方法：
#import 模块名 直接调用了模块中的所有方法
import random#从系统库中引入这个模块
test = random.randint(1,10)#使用random模块中的randint()方法
print('生成一个随机数：',test)
#import 模块名 as 别名（注意在命名的时候不要使用符号）
import math as t
test = t.cos(2.5)
print(test)
# from 模块名 import 函数名 仅仅调用了模块中的一个函数
from random import randint
test = randint(1,10)
print(test)math模块：
#math模块提供了关于数学方面的功能，可以帮助我们进行指数、对数、平方根、三角函数等运算。
math.log(x[,底数]) 对数运算，以基数为底的x的对数，如果省略底数就是以2为底
math.sqrt(x) 平方根运算，x的平方根
math.pow(x,y) 取幂运算，x的y次幂
#三角函数
math.sin(x) 三角正弦值
math.cos(x) 三角余弦值
math.tan(x) 三角正切值
math.asin(x) 弧度的反正弦
math.acos(x) 弧度的反余弦
math.atan(x) 弧度的反正切
math.degress(x) 弧度转角度
math.radinans(x) 角度转弧度
math.ceil(x) 返回大于x或等于x的最小整数。
math.floor(x) 返回小于x或等于x的最大整数
round(x) 四舍五入
#例子
import math
a = math.log(144,12)
b = math.sqrt(36,6)
c = math.pow(10,3)
print(a)
print(b)
print(c)
b = math.cos(30)
c = math.tan(30)
d = math.asin(0.6)
e = math.acos(0.6)
f = math.atan(0.6)
g = math.degrees(2 * math.pi)
h = math.radians(360 / math.pi)
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)
a = math.ceil(3.5)
b = math.floor(3.5)
c = round(3.5)
d = round(3.4)
print(a)
print(b)
print(c)
print(d)random模块：
random.random() 生成一个[0,1)的实数。
random.randint(a,b) 生成一个[a,b]的数字，包含a和b。
random.randrange(a,b) 生成一个[a,b)的数字，包含a，不包含b。
random.shuffle(x) 把序列x打乱。
random.choice(x) 从x中返回一个随机项，x需要是一个可变序列。
random.uniform(a,b) 生成一个a,b之间的浮点数，区间可以是浮点数。
#例子
import random
a = random.random()
print(a)
a = random.randint(1,3)
print(a)
a = random.randrange(1,3)
print(a)
a = ['d','o','t','c','p','p']
print('打乱前的列表：',a)
random.shuffle(a)
print('打乱后的列表：',a)
a = ['d','o','t','c','p','p']
print(random.choice(a))
a = random.uniform(1.1,3.3)
print(a)datetime模块：
datetime：
#datetime
datetime的使用方法为：
datetime.dateto,e(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)
year，month和day是不能缺少的，
tzinfo为时区参数，可以为None或其他参数
MINYEAR <= year <= MAXYEAR,
1 <= month <= 12,
1 <= day <= number of days in the given month and year,
0 <= hour < 24,
0 <= minute < 60,
0 <= second < 60,
0 <= microsecond < 1000000,
fold in [0, 1].
#常用的方法
datetime.datetime.now() 返回当前的日期和时间
date() 返回当前时间的日期
time() 返回当前的时间对象
utctimetuple() 返回UTC时间元组
#例子
import datetime
t = datetime.datetime.now()#返回当前日期及时间
print(t)
t = datetime.datetime.now()#返回当前日期及时间
print(t.date())#输出当前的日期
t = datetime.datetime.now()#返回当前日期及时间
print(t.time())#输出当前的时间
t = datetime.datetime.now()#返回当前日期及时间
print(t.utctimetuple())#输出当前的日期date：
#date
date对象是日期的专属对象
datetime.date(year,month,day)，参数分别代表年月日。
#常用方法：
datetime.date.today() 返回了当前的日期
datetime.date.fromtimestamp() 返回与时间戳对应的日期
#例子：
import datetime
t = datetime.date.today()#返回当前日期
print(t)
import datetime
import time
c = time.time()#返回当前的时间戳
print('当前的时间戳为:',c)
t = datetime.date.fromtimestamp(c)#与时间戳对应的日期
print('当前时间戳对应的日期为:',ttime：
#time
time类中包含了一整天的信息
datetime.time(hour,moniute,second,microsecond,tzinfo=None)
#例子：
import datetime
t = datetime.time(19,42,34,12)
print(t)第三方模块：
安装：
1 cmd安装：
window+r=====>输入cmd====>输入pip list ====>输入 pip install 模块名
2 Pycharm中安装
异常处理：
常见异常：
- KeyError异常：
访问字典的键，而键值不存在的时候发生的异常
my_dict={'dotcpp':123}
(my_dict['dot'])
报错信息：
- IndexError异常
访问序列元素的时候，索引值超出范围的时候会触发这种异常机制
my_list=[1,2,3,4,5]
(my_list[100])
报错信息：
- NameError异常
使用一个未定义的变量时会引发此异常
name=['www.dotcpp,com']
('存在的变量name:',name)
('不存在的变量dotcpp:',dotcpp)
报错信息:
- TypeError异常
传递的数据与规定的类型不一致的时候
a=10
b='dotcpp'
(a+b)
报错信息：
异常处理语句：
-
try...except语句
#语法
try:
block
Except [typeerror ]:
deal
block 程序执行过程中可能会抛出异常的语句，
typeerror 错误类型，省略不指定类型，即捕获全部异常
deal 具体的处理语句
#例子：
def test():
number = int(input('请输入一个数字:'))
if 15 / number >= 3:
print('ok')
else:
print('wrong')
try:
test()
except:
print('分母为0的异常情况')-
except代码块
#try...except语句一种扩展，于一个问题可能会出现多种错误的情况，那么我们可以对每一种情况都做一定的处理
Try:
Test()
except [异常类型1]：
deal
except [异常类型2]:
deal
except [异常类型3]:
deal
#例子：
def test():
number = int(input('请输入一个数字:'))
if 15 / number >= 3:
print('ok')
else:
print('wrong')
try:
test()
except ZeroDivisionError:
print('分母为0的异常')
except ValueError:
print('传入的值异常')-
try...except语句的嵌套：
def test():
n = int(input('有3个语句需要测试,请选择(1/2/3)：'))
if n == 1:#keyError异常情况
my_dict = {'dotcpp': 123}
print(my_dict['dot'])
elif n == 2:#IndexError异常
my_list = [1, 2, 3, 4, 5]
print(my_list[100])
elif n == 3:#NameError异常
print('不存在的变量dotcpp:', dotcpp)
try:
try:
try:
test()
except KeyError:
print('KeyError异常')
except IndexError:
print('IndexError异常')
except NameError:
print('NameError异常')-
try...except...finally语句：
#一个完整的异常处理机制是离不开finally语句，不管我们的程序中是否有异常发生，finally语句下的代码都会被执行
try:
block
except [typeerror]:
deal1
finally:
deal2
#例子：
def test():
n = int(input('请输入一个整数:'))
print(n)
try:
test()
except KeyError:
print('KeyError异常')
finally:
print('finally语句已执行')-
try...except...else语句：
#当程序中未发生异常的时候才会执行
try:
block
except [typeerror ]:
deal1
else:
deal2
#例子：
def test():
n = int(input('请输入一个整数:'))
print('输入值为：',n)
try:
test()
except ValueError:
print('ValueError异常')
else:
print('当前程序未出现异常')程序调试：
使用IDLE调试：
python.exe==>Debug==>Debugger==>DEBUG ON](已开启调试状态)==>选择调试的代码 ==>右击Set Breakpoint(添加断点)/(Clear Breakpoint删除断点)==>F5键开始调试==>关闭页 面停止调试
使用assert断言调试：
assert expression[,describe]
expression:一个表达式，真不采取操作，反之AssertionError异常
#例子：
n = int(input('请输入一个整数:'))
m = int(input('请输入一个整数:'))
assert n > m,'wrong'
print('程序可以正常运行')
6442
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
