1.函数与面向对象

一、函数

func2 = lambda x,y: x+y

def func(x,y):
   return x+y

二、参数

1、位置参数，有几个位置参数就传几个，必须在关键字参数之前

def method(a,b):
  print(a)
  print(b)
method(1,23)

2、默认参数为给参数一个以上默认值k = v，调用时有默认值的参数可传可不传，必须在位置参数后

def method(a,b=5):
  print(a)
  print(b)
method(1)
method(1,3)

3、非固定参数也叫可变参数，不固定的*args，必须在位置与默认参数后

def method(a,b=2,*args):
  print(a)
  print(b)
  print(args)
method(1,23,"3","ab")  #注意，非固定参数传进来的是一个元祖
#输出：
1
23
('3', 'ab')

4、关键字参数也是不固定的，**args,在调用函数的时候使用×××=×××，传入的是一个字典，多种参数一起使用，放在最后面

def method(a=3,**args):
  print(a)
  print(args)
method(3,c=2,key=5,e=6)
#输出：
3
{'c': 2, 'key': 5, 'e': 6}

注意：参数定义顺序：位置参数、默认参数、非固定参数，关键字参数

三、全局变量与局部变量

全局变量，如果在函数中修改，需要加global关键字声明；如果是list、字典和集合的话，则不需要加global，可直接修改

局部变量

a=3
def method():
  a=4
  return a

def method2():
  print(a)

method2()
method()
method2()
#输出：
3
4
3           #实际上a并没有变化

全局变量

a=1
def method():
  global a
  a = 4
  return a
def method2():
  print(a)
method2()
method()
method2()
#输出：
3
4
4     #a的值发生了变化

列表局部变量

a=[1,3]
def method():
    a.append(5)
    return a
def method1():
    print(a)

method1()
print(method())
method1()
#输出：
[1, 3]
[1, 3, 5]
[1, 3, 5]

四、两种编程思想

• 面向过程
  一种以过程为中心的编程思想
  简单的事情

• 面向对象
  面向对象开发就是不断地创建对象，使用对象，操作对象做事情
  复杂地事情

• 类
  封装代码和数据
  是一系列可被公共使用的接口

• 具体构造
  类， 一类事物
  方法， 类中定义的函数，对外提供的服务
  类变量， 在整个实例化的对象中是公用的
  实例引用：实例化一个对象
  实例变量：以’self.变量名‘的方式定义的变量

创建一个类

# 通过 class 关键字，进行定义了一个类
class Person:
    # 类变量
    name = "tly"
    age = 29
    gerder = 'male'

  # 构造方法，在类实例化的时候自动被调用
  def __init__(self,name,age,weight):
    # self.变量名的方式，访问的变量，叫做实例变量
    self.name = name
    self.age = age
    self.weight = weight

  @classmethod
  def eat(self):
    print(f"{self.name} is eating")

  def play(self):
    pass

# 类方法和实例方法的区别
# Person.eat() 类方法不可访问 实例方法；如何访问呢，类方法加装饰器classmethod，
zs = Person('zhangsi',31,231)
zs.eat()

# 类变量和实例变量的区别：都可以被修改
print(Person.name)
zs = Person('zhangsan',23,'男',139)
print(zs.name)

#实例化一个对象，类的实例化，创建了一个实例
zs = Person("zhangsan",21,30kg)
#类的方法
zs.set_age(28)
zs.name("hji")
zs.eat()