函数
函数的定义及调用
自定义函数
def get_sum(num):#num形式参数
s=0
for i in range(1,num+1):
s+=i
print(f'1到{num}之间的累加和为:{s}')
#函数的调用
get_sum(10)# 1-10之问的累加和 10是实际参数值
get_sum(100)# 1-100之间的累加和 100是实际参数值
get_sum(1000)#1-1000之间的累加和 1000是实际参数值
函数的参数传递
1.位置参数
def happy_birthday(name,age):
print('祝'+name+'生日快乐')
print(str(age)+'生日快乐')
#正确的调用方式
happy_birthday('小明',18)
2.关键字参数
def happy_birthday(name,age):
print('祝'+name+'生日快乐')
print(str(age)+'生日快乐')
#正确的调用方式（1）关键字
happy_birthday(age=18,name='小明')
#（2）位置+关键字
happy_birthday('小明',age=18)
注：位置参数在前，关键字参数在后 所以happy_birthday(name='小明',18)报错
3.默认值参数
def happy_birthday(name='小明',age=18):#默认值参数的定义
print('祝'+name+'生日快乐')
print(str(age)+'生日快乐')
#正确的调用方式（1）
happy_birthday()#不用传参
#（2）位置传参
happy_birthday('小明')
#（3）关键字传参
happy_birthday(age=19)#name采用默认值
当位置参数和关键字参数同时存在的时候，应当遵循 位置参数在前，默认值参数在后
4.可变参数
在调用时，前加星号会进行系列解包操作
函数的返回值
变量的作用域
匿名函数lambda
#只有一句的函数
def calc(a,b):
return a+b
print(calc(10,20))
#匿名函数
s=lambda a,b:a+b
print(type(s))
print(s(10,20)
还可以用于成绩排序：
student_scores=[
{'name':'john','score':87},
{'name':'irene','score':95},
{'name':'lily','score':80},
{'name':'winter','score':100}
]
student_scores.sort(key=lambda x:x.get('score'),reverse=True)
print(student_scores)
递归函数
斐波那契数列
def fac(n):
if n==1 or n==2:
return 1
else:
return fac(n-1)+fac(n-2)
print(fac(9)) #34
常用的内置函数
数据类型转换函数
常用的数学函数
注：
int（'3.14'）这种写法在转整型里是不合法的（在字符串中写浮点数）
常用的迭代器函数
常用的其他内置函数
注：format，数值默认右对齐，字符串默认左对齐
print(format(3.14,'20')) #数值默认右对齐
print(format('hello','20')) #字符串默认左对齐
print(format('hello','*<20'))#<左对齐，*表示填充符，20表示显示的宽度
print(format('hello','*^20'))
print(format(3.1415926,'.2f'))#保留两位小数
实战一
import random
def get_max(lst):
max=lst[0]
for i in range(1,len(lst)):
if max<lst[i]:
max=lst[i]
return max
lst=[random.randint(1,100) for i in range(10)]#列表生成式
print(lst)
print(get_max(lst))
实战二
def get_digit(x):
s=0
lst=[]
for item in x:
if item.isdigit():
lst.append(int(item))
s=sum(lst)
return lst,s
s=input('请输入一个字符串：')
lst,x=get_digit(s) #系列解包赋值
print('提取的数字列表为：',lst)
print('累加和为：',x)
实战三
def lower_upper(x):
lst=[]
for item in x:
if 'A'<=item<='Z':
lst.append(chr(ord(item)+32))#ord()将字母转为Unicode值，加上32，chr（）整数转成字符
elif 'a'<=item<='z':
lst.append(chr(ord(item)-32))
else:
lst.append(item)
return ''.join(lst)
s=input('请输入一个字符串：')
print(lower_upper(s))
实战四
def get_find(s,lst):
for item in lst:
if s==item:
return True
return False
lst=['hello','world','python']
s=input('请输入你要判断的字符串：')
result=get_find(s,lst)
print('存在' if result else '不存在') # if--else的简写，三目条件运算符
面向对象程序设计
面向过程和面向对象思想的异同
类和对象
- 类： 是由n多个对象中抽取像的属性和行为从而归纳出来的
- 在Python中一切皆对象
- 自定义数据类型的语法结构：
class 类名（）：
pass
但是你自定义完之后，目前还是不可以使用，它相当于你绘制了一个图纸，只有你创建对象之后才可以使用，对象是具体的实例
- 创建对象的语法结构
对象名=类名（）
对象名也就是一个变量名
类的组成
创建和调用
class Student:
#类属性：直接定义在类中，方法外的变量
school='扬州教育中心'
# 初始化方法，实例属性需要定义在_init_方法中，使用self打点的变量
def __init__(self,xm,age):
self.name=xm #左侧是实例属性，xm是局部变量，将局部变量的值xm赋值给实例属性self.name
self.age=age #实例的名称和局部变量的名称可以相同
#定义在类中的函数，称为方法，且自带参数self
def show(self):
print(f'我叫:{self.name},今年{self.age}岁了')
#静态方法
@staticmethod
def sm():
#self.name()
#self.show()
print('这是一个静态方法，不能调用实例属性，也不能调用实例方法')
#类方法
@classmethod
def cm(cls):
print('这是一个静态方法，不能调用实例属性，也不能调用实例方法')
#创建类对象
stu=Student('phy',18)
#类属性（直接使用类名去打点调用）
print(Student.school)
#实例属性（它使用对象名进行打点调用，而并不是用self）
print(stu.name,stu.age)
#实例方法（使用对象名进行打点调用）
stu.show()
#静态方法（直接使用类名打点调用）
Student.sm()
#类方法（直接使用类名打点调用）
Student.cm()
动态绑定属性和方法
- 每个对象的属性名称相同，但属性值不同
- 可以为某个对象绑定独有的属性或方法
动态绑定属性
动态绑定方法
面向对象的三大特征（封装，继承，多态）
1.封装
python中的权限控制
如果非要访问双下划线的私有属性或方法的话
对象的名字._类的名字_ _属性名
对象的名字._类的名字_ _方法名（）
关于属性设置问题：（私有属性）
class Student:
def __init__(self,name,gender):
self.name=name
self.__gender=gender#私有
#让@property修饰方法，来把方法修改（转）为一个属性去使用
#虽然这样私有属性就可以显示了，但是它只可读不可写
#如果非要写，就需要setter
@property
def gender(self):
return self.__gender
#将我们gender这个属性设置为可写属性
@gender.setter
def gender(self,value):
if value!='男' and value!='女':
print('性别有误，已将性别默认值为男')
self.__gender='男'#设置默认值
else:
self.__gender=value
stu=Student('zyx','女')
print(stu.name,'的性别是',stu.gender)
#改
stu.gender='其它'
print(stu.name,'的性别是',stu.gender)
2.继承
(1) 一个父类可以有多个子类
(2) 一个子类可以继承多个父类（多继承）
方法重写
即：在子类里再写一个方法，方法名要跟你要重写的这个父类的方法名相同
当然你也可以完全重写，不使用super调用父类内容
比如：
3.多态
object类（对象)
对象的特殊方法（首尾双下划线）
dir（）内置函数，可以查看你的类的对象，它所具有的属性或方法
a=10
b=20
print(dir(a)) # Python巾一切皆对象
print(a+b) #执行加法运算
print(a.__add__(b))
print(a.__sub__(b))#执行减法运算
print(f'{a}<{b}吗? ',a.__lt__(b))
print(f'{a}<={b}吗? ',a.__le__(b))
print(f'{a}=={b}吗? ',a.__eq__
(b))print( ' -'*40)
print(f'{a}>{b}吗? ',a._gt__(b))
print(f'{a}>={b}吗? ',a._-ge__(b))
print(f'{a} !={b}吗? ',a.__ne__(b))
