一、Python的函数

为什么要函数？

重复对某类对象进行某种操作时——例如要对多个列表进行排序、去重；对多个学生的成绩进行统计、保存到文件等。如果把每个对象的每个操作都写一遍，会出现很多重复或类似的代码。因此，我们引入函数，来简化这一流程。
当某一个功能需要很多行代码实现时，可包装成一个函数，让整个程序步骤清晰，提高可读性。
Python的一大特点是模块化编程。与小伙伴合作开发、或者给其他人提供工具时，可把你实现的功能包装成一个函数，供他人使用。

函数基础和参数

在python里，定义函数非常简单，不需要区分函数原型和函数实现等，也不需要指定参数类型和函数类型（返回值类型）。
例如：

def printTen(x):
	print(x*10,end=" ")
	print("函数调用成功")
	
y = 5  # 创建了一个变量
printTen("abc")  # 函数调用
printTen("学联部牛逼")

# 5 -> 6 -> 1 (x="abc") 传参 -> 2 print(10*"abc") -> 3 
# -> 7 -> 1 (x="学联部牛逼") -> 2 -> 3 -> 结束

def 是定义函数的关键字
printTen 是函数名，可以随意取
括号里的x是参数，括号后面跟一个冒号
下面是函数体，用缩进表示

python只有函数定义和函数调用。
函数一旦被定义，在函数下面的全局作用域内和其他函数内可以调用。

例如：

# printTen(10) # 不可以调用！
def xlbnb(a):  # python碰到def，先知道有这个函数，但并不会立即执行里面的语句
	printTen(a)  # 可以调用，神奇诶！
	print("xlbnb")
def printTen(x):
	print(x*10,end=" ")
# 以上是函数定义，以下是函数调用
printTen(5)  # 这里肯定可以调用
printTen([1,2,3])
printTen("我爱学联部，我爱WYS")
xlbnb(20)

输出结果

50
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
我爱学联部，我爱WYS我爱学联部，我爱WYS我爱学联部，我爱WYS我爱学联部，我爱WYS我爱学联部，我爱WYS我爱学联部，我爱WYS我爱学联部，我爱WYS我爱学联部，我爱WYS我爱学联部，我爱WYS我爱学联部，我爱WYS
200
xlbnb

也就是说，printTen(x)上面的局部作用域、下面的全局作用域、下面的局部作用域都可以调用，但上面的全局作用域不能调用。

局部作用域：指函数、类的内部
全局作用域：不是局部就是全局啊~~

Python不会对函数参数类型进行检验。函数就像一个榨汁机，传入苹果得到苹果汁，传入胡萝卜得到胡萝卜汁，传入傻傻的我得到小傻汁。
虽然我们可以给函数的参数设置类型，但这是给编辑器和其他程序员看的。例如指定了参数为int型，传入list并不会报错，只会被编辑器警告。
指定参数类型：

def repeat(x:str,y:int): # 把字符串x重复y遍
	print(x*y)
repeat("祝大家期末全部80+", 5) # 正常调用
repeat(10, 5) # 未按照规则调用，编译器会警告，但不会报错，会正常输出50
repeat("abc", "ddd") # 直接报错，因为str和str不能相乘

函数返回值

python通常用return语句来表示函数的返回值。return 后面空一格。

返回值也不需要预先指定类型，根据执行过程确定。

def absolute(a, b): # 求绝对值的函数
	if a>b:
		return a-b
	else:
		return b-a
		
print(absolute(3,5)) -> 2
x = absolute(10,7)
print(x) -> 3

def returnTen(x):
    return 10*x

x = returnTen("abc") + returnTen("ha")

# 1. 执行returnTen("abc") 返回abcabcabcabcabcabcabcabcabc
# 2. 执行returnTen("ha") 返回hahahahahaha...
# 3. 将上面的两个字符串加起来（拼接）
# 4. 将结果存到x里面

一个函数只能返回一个对象。如果要返回多个值，可以考虑封装成列表或者元组。
一个函数可能返回多种类型的值。例如

def getDivMod(a:int,b:int): # 获得整除的数和余数 10 / 3 = 3......1  返回[3,1]
	if b==0:
		return "0不能做除数" # 字符串
	else:
		return [a//b, a%b] # 返回商和余数

函数中单独的return代表不返回任何值（也可以说返回None），并跳出函数
可以通过箭头指定返回值类型，但依然是给编辑器和人看的，即使返回值不是这种类型，也能正常运行。

def maxLength(la:list, lb:list) -> list:  # 返回长度大的列表
	if len(la) < len(lb):
		return lb
	else:
		return la

*函数参数

函数可以没有参数，可以有一个或多个参数，也可以有不定个数的参数。

参数可以有默认值。例如：

def add(a=1, b=2, c=3):
   return a+b+c
add() -> 6  # 一个参数也不传，全部参数会被设置成默认值
add(10) -> 15  # 只传入一个参数，a=10，b、c为默认值，b=2，c=3 
add(10,20,30) -> 60  # 三个参数都传入
add(c=5,b=5) -> 11  # 可以指定哪一个参数的值是多少
add(a="I ",c="WYS",b="love ") -> "I love WYS" # 甚至可以反其道而行之，传入三个字符串

参数的默认值只能设置为“后n个”。换言之，如果这个参数设置了默认值，其后的参数就必须全部设置默认值，比如def add(a,b,c)，如果a设置了默认值，b、c必须也设置默认值；如果b设置了默认值，c也必须设置默认值。不可以只给b设置，c不设置。详见代码和注释：

def add(a=1, b=2, c=3)  # ok
def add(a, b, c)  # ok
def add(a, b, c=3)  # ok
def add(a, b=2, c=3)  # ok

def add(a=2, b, c=3)  # not ok
def add(a=4, b, c) # not ok
def add(a, b=2, c) # not ok

调用函数时，可以指定某一个参数的值是多少。事实上，print(a,end=' ')就是指定了print()函数的end参数的值。如果不指定，调用函数时传的实参（括号里的东西）就依次赋给每一个形参。详见代码和注释：

def add(a, b=2, c=3):
   return a+b+c
   
add(6) -> 11  # 传入一个6，在def里面，a被赋值为6，返回6+2+3的值
add(2,5) -> 10 # 传入2和5，a=2,b=5,c没指定，被赋值为默认值3，因此返回2+5+3
add(c=500, a=20, b=1) -> 521  # 三个参数都传入，并且指定了参数的值
add() -> ERROR!  # a没有默认值，调用时必须传入！
add(b=4,c=5) -> ERROR!  # a没有默认值，我一定要你传a进去！b、c传不传看你心情，但a必须传！

二、面向对象

面向过程VS面向对象例子：植物大战僵尸
面向过程：将要解决的问题划分成一个个的过程。
如：

洗漱()
课程对象:
	上课()
	听老师讲课()
	下课()
和WYS一起吃饭()
和WYS一起自习()
	写报告()
	敲代码()
	复习()

对象的组成：属性和方法
面向对象

 属性：对象本身具有的特性 
 方法：对象可以进行的操作

class Cat:  # 定义了一个猫猫类
    def __init__(self,setName):  # 构造函数（初始化方法）：对象被建立时直接调用
        self.name = setName  # 属性
        print("你获得了一只叫%s的猫猫" % self.name)
        self.weight = 20
        self.voice = "喵~"
    def meow(self):  # 方法:猫叫
        print(self.voice * 10)
    def eat(self,addw):
        self.weight += addw
    def setHeight(self,h):
        self.height = h

cat1 = Cat("小花")  # 通过猫类 实例化 猫对象
cat1.voice = "喵呜！"
cat1.meow()

cat2 = Cat("猫咪")  # 通过猫类 实例化 另一个猫对象
cat2.meow()  # 这两个猫对象 调用同样的方法 结果并不一样

类——用于定义表示用户定义对象的一组属性的原型。
实例化——通过类创建对象的操作。
面向对象三大特性：封装、继承、多态
封装：把具有相似属性和方法的对象封装成类，通过类可以实例化多个对象。
继承：让某个类型的对象获得另一个类型的对象的属性的方法。 “父类”->“子类” / “基类”->“派生类”
```
 类->类 ——继承
 类->对象 ——实例化
```

多态：同一个类创建出的不同的对象，调用同样的方法，执行的操作不相同，其属性也不同。如“动物”类实例化出“狗”对象和“猫”对象，其“体重”属性不同，“叫声()”方法执行的操作也是不同的。

前端和后端

前端就是用户能看到的界面。你可以在应用程序或网站的屏幕上看到的所有内容都属于前端。
web前端：网页成分的设计
UI开发
后端就是背后的逻辑

前后端分离

前后端全栈开发工程师

不限制语言所以我们用的最多的就是python 其次是C/C++

函数与面向对象基础