Python基础（下）

前言

 print("\n".join([''.join(['*'*((x-y)%3) if((x*0.05)**2+(y*0.1)**2 -1)**3-(x*0.05)**2*(y*0.1)**3<=0 else ' ' for x in range(-30,30)]) for y in range(15,-15,-1)]))

函数基础（function）

1.定义函数

定义函数需要用到def关键词，格式如下：

 def 函数名():
     此函数做的事情1
     此函数做的事情3
     此函数做的事情2
     ...省略...

定义了函数后，相当于有了一个具有某功能的代码块，想要调用函数，通过函数名()即可。详细示例如下：

 def addition():#定义函数
     a = 2
     b = 3
     c = a + b
     print(c)
 addition()#调用函数

2.函数注释说明

若想给函数添加注释说明，让外部调用者知道函数的大体功能，可以通过如下格式进行函数文档说明的添加：

 def addition():#定义函数
     '两个数字求和'
     a = 2
     b = 3
     c = a + b
     print(c)
 addition()#调用函数

3.函数参数

定义带有参数的函数的方式如下：

 def addition(a,b):#定义带入参数的函数
     '两个数字求和'
     c = a + b
     print(c)
 addition(2,3)#调用带入参数的函数

4.函数返回值

想要函数中把结果返回给调用者，需要在函数中使用return。示例如下：

 def addition(a,b):#定义函数
     '两个数字求和'
     c = a + b
     return c
 result = addition(2,3)#调用函数
 print(result)

5.函数类型

定义函数时小括号内的参数，用来接收参数所用，称为“形参”。

调用函数时小括号内的参数，用来传递给函数所用，称为”实参“。

函数一共有4种类型：

1.无参数，无返回值。

2.有参数，无返回值。

3.无参数，有返回值。

4.有参数，有返回值。

函数高级

1.函数返回多个值

python允许函数有多个返回值，本质时利用了元组，示例如下：

 def addition(a,b):
     return a+1,b+1
 result = addition(2,3)
 print(result)

2.缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为时默认值，我们给参数赋值默认值的方式如下示例所示：

 def addition(a,b=3):
     return a+1,b+1
 result = addition(2)
 print(result)

注意：缺省参数一定要位于参数列表的最后面。

3.不定长参数

有时需要函数处理比当初声明时更多的参数，这些参数叫做不定长参数，声明时不会命名。实现不定长参数的方式有两种，

1.使用*参数名的方式，本质是一个元组。

2.使用**参数名的方式，本质是一个字典。

使用*变量名方式的示例如下：

 def addition(a,b,*arg):
     print(a)
     print(b)
     print(arg)
 addition(1,2,3,4,5,6)

使用**变量名方式的示例如下：

 def addition(a,b,**kwargs):
     print(a)
     print(b)
     print(kwargs)
 addition(1,2,name='jonins',age='')

一个复杂例子说明：

 def addition(a,b,c=3,*args,**kwargs):
     print(a)
     print(b)
     print(c)
     print(args)
     print(kwargs)
 print('--------2个必填参数---------')
 addition(1,2)
 print('-------2个必填1个缺省其它为不定长*args----------')
 addition(1,2,3,4)
 print('-------2个必填1个缺省其它为不定长**kwargs----------')
 addition(1,2,name = 'jonins',age = '')
 print('-------2个必填1个缺省有不定长*args和**kwargs----------')
 addition(1,2,3,4,5,6,name = 'jonins',age = '')

变量先赋值普通参数，省却参数，最后为不定长变量。参数的声明顺序也要遵循如下顺序声明。

传递多余的参数，如果前面不带变量名，统统传值给*变量名以元组形式保存。

传递多余的参数，如果前面带有变量名，统统传值给**变量名以字典形式保存。

拆包

我们先看一个示例：

 def addition(a,b,*args,**kwargs):
     print(a)
     print(b)
     print(args)
     print(kwargs)
 A = {1,2,3,4}
 B = {"name":"jonins","age":18}
 addition(1,2,A,B)

因为值的前面不存在变量名，所以统统放进了元组中，若想将元组变量和字典变量，直接替换不定长参数中的变量，则需要拆包（元组前加1个*，字典前加2个*）：

 def addition(a,b,*args,**kwargs):
     print(a)
     print(b)
     print(args)
     print(kwargs)
 A = {1,2,3,4}
 B = {"name":"jonins","age":18}
 addition(1,2,*A,**B)

全局变量&局部变量

局部变量，就时在函数内部定义的变量。不同函数，可以i当以相同名字的局部变量，但是各用各的不会产生影响。局部变量的作用是为了临时保存数据需要在函数中定义变量来进行存储。

如果一个变量，既能在一个函数中使用，也能在其它的函数中使用，这样的变量就是全局变量。

示例如下：

 a = 100
 def test1():
     print('test1,%i' % a)
 def test2():
     print('test2,%i' % a)
 def test3():
     a = 200
     print('test3,%i' % a)
 def test4():
     global a
     a = 200
     print('test4,%i' % a)
 test1()
 test2()
 test3()
 print('未使用global时，全局变量外部为:%i'%a)
 test4()
 print('使用global时，全局变量外部为:%i'%a)

说明：

1.函数外边定义的变量叫做全局变量。

2.全局变量能够在所有函数中进行访问

3.如果在函数中修改全局变量，需要使用global进行声明。

4.如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的值（若名称相同情况出现，默认是定义一个局部变量，global时是修改）。

引用

1.变量赋值本质

python中变量的赋值并非单纯的将值复制过去一份保存起来，而是将变量值的引用复制过去保存一份。

python中变量赋值过程大致描述：

C或C++中变量赋值过程大致描述：

可以通过id()方法验证，id() 函数用于获取对象的内存地址,示例如下：

 a=100
 b=a
 c=b
 print(id(a))
 print(id(b))
 print(id(c))

2.可变类型&不可变类型

python值靠引用的传递，那么一个变量的值改变了，同样引用的其它变量的值是否会变呢？

 A = ['','','','']
 B = A
 A.append('')
 print(B)
 a = 100
 b = a
 a = 200
 print(b)

我们可以看到列表的变量的值随其它同引用变量对值的修改而发生了变化，但数值类型的变量却没有发生变化，这是因为python中类型分为可变类型与不可变类型。

可变类型，值可以改变：

列表（list）、字典（dict）

不可变类型，值不可以改变：

数值类型（int、long、bool、float）、字符串（str）、元组（tuple）

注意：本质上不可变量类型在原值发生变化时，重新开辟空间生成了一个值的存储区域并引用了新的地址，验证示例：

 a = 100
 b = a
 print(id(a))
 print(id(b))
 a = 200
 print('--修改值后--')
 print(id(a))
 print(id(b))

类基础（class）

python是面向对象的，而面向对象编程的2个非常重要的概念就是：类和对象（如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在这里不做过多描述）。

对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了一个新的概念：类。而类的具体”实现“就是：对象。

1.定义类&实现类

类的定义和对象的实现的基本语法格式如下：

 class CSharpCoder(): #定义类、经典类方式定义
     'C#程序员' #CSharpCoder类的描述信息
     pass
 class PythonCoder(object): #定义类、新式类方式定义
     'Python程序员' #PythonCoder类的描述信息
     pass
 cp_cder = CSharpCoder() #实现CSharpCoder类的对象
 py_cder = PythonCoder() #实现PythonCoder类的对象

说明：

1.python中定义类有两种方式：新式类和经典类。

2.规范要求类的命名方式采用：大驼峰。

3.pass：空语句，是为了保持程序结构的完整性，不做任何事情，一般用做占位语句。

4.类的注释和函数的注释作用及语法是一样的。

2.定义属性

类中定义属性的示例如下：

 class CSharpCoder():
     name = ''
 cp_cder = CSharpCoder()
 cp_cder.name = 'Jonins'
 print(cp_cder.name)

3.定义方法

类中定义方法的示例如下：

 class CSharpCoder():
     name = 'k'
     def get_name(self):
         print(self.name)
 cp_cder = CSharpCoder()
 cp_cder.name = 'Jonins'
 cp_cder.get_name()

python编写类的内置函数时，第一个参数都是self。

因为当类初始化时会得到实例，self就是用于代表初始化得到的实例。在python设计之初，完全可以考虑似于Javascript中的this或C#隐藏掉实例让人无感知（除非需要用到this）。

但是python的哲学是“Explicit is better than implicit”因此python类中的方法需要一个self参数代表实例。

4.构造函数（init）

python中类的的构造函数需要用到：__init__，使用示例如下：

 class CSharpCoder():
     name = 'k'
     def  __init__(self,name):
         print('实例化对象中...')
         self.age = 18
         self.name = name
     def get(self):
         print(self.age)
         print(self.name)
 cp_cder = CSharpCoder('Jonins')
 cp_cder.get()

说明：

1.__init__()方法，在实例化一个对象时默认被调用的初始化方法，不需要手动调用。
2.__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去。
3.构造函数即实例化对象的一个标准，当__init__()方法指定self参数以外的参数时，外部实例化对象时必须传递所需的参数，否则报错。

5.析构函数（del）

析构函数，在释放对象时使用，需要用到__del()__，示例如下：

 class CSharpCoder():
     def  __init__(self):
         print('实例化对象中...')
     def __del__(self):
         print('释放对象中...')
 cp_cder = CSharpCoder()
 del cp_cder #删除对象

析构函数在对象被删除时会自动调用。

6.类专有函数

__init__ ：构造函数，在生成对象时调用
__del__ ：析构函数，释放对象时使用
__repr__ ：打印，转换
__setitem__ ：按照索引赋值
__getitem__：按照索引获取值
__len__：获得长度
__cmp__：比较运算
__call__：函数调用
__add__：加运算
__sub__：减运算
__mul__：乘运算
__div__：除运算
__mod__：求余运算
__pow__：乘方

self&__xxx__

1.self（自身）

所谓的self，可以理解为”自己“，类似于C++中类里面的this指针一样理解，就是对象自身的意思。
某个对象调用其方法时，python解释器会把这个对象自身当作第一个参数传递给self，所以开发者只需要传递后面的参数即可。

2.__xxx__（魔法方法）

在python中，方法如果是：__xxx__()形式的（双下划线所包围），就表示具有一些特殊的功能，统称为“Magic Method”，即魔法方法。

这些特殊方法不需要直接调用，在特殊的情况下这些特殊方法会自动被python调用。下面是python魔法方法的整理列表（整理自网络）：

魔法方法	含义
基本的魔法方法
__new__(cls[, ...])	1. __new__ 是在一个对象实例化的时候所调用的第一个方法 2. 它的第一个参数是这个类，其他的参数是用来直接传递给 __init__ 方法 3. __new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __new__ 没有返回实例对象，则 __init__ 不会被调用 4. __new__ 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
__init__(self[, ...])	构造器，当一个实例被创建的时候调用的初始化方法
__del__(self)	析构器，当一个实例被销毁的时候调用的方法
__call__(self[, args...])	允许一个类的实例像函数一样被调用：x(a, b) 调用 x.__call__(a, b)
__len__(self)	定义当被 len() 调用时的行为
__repr__(self)	定义当被 repr() 调用时的行为
__str__(self)	定义当被 str() 调用时的行为
__bytes__(self)	定义当被 bytes() 调用时的行为
__hash__(self)	定义当被 hash() 调用时的行为
__bool__(self)	定义当被 bool() 调用时的行为，应该返回 True 或 False
__format__(self, format_spec)	定义当被 format() 调用时的行为
有关属性
__getattr__(self, name)	定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self, name)	定义当该类的属性被访问时的行为
__setattr__(self, name, value)	定义当一个属性被设置时的行为
__delattr__(self, name)	定义当一个属性被删除时的行为
__dir__(self)	定义当 dir() 被调用时的行为
__get__(self, instance, owner)	定义当描述符的值被取得时的行为
__set__(self, instance, value)	定义当描述符的值被改变时的行为
__delete__(self, instance)	定义当描述符的值被删除时的行为
比较操作符
__lt__(self, other)	定义小于号的行为：x < y 调用 x.__lt__(y)
__le__(self, other)	定义小于等于号的行为：x <= y 调用 x.__le__(y)
__eq__(self, other)	定义等于号的行为：x == y 调用 x.__eq__(y)
__ne__(self, other)	定义不等号的行为：x != y 调用 x.__ne__(y)
__gt__(self, other)	定义大于号的行为：x > y 调用 x.__gt__(y)
__ge__(self, other)	定义大于等于号的行为：x >= y 调用 x.__ge__(y)
算数运算符
__add__(self, other)	定义加法的行为：+
__sub__(self, other)	定义减法的行为：-
__mul__(self, other)	定义乘法的行为：*
__truediv__(self, other)	定义真除法的行为：/
__floordiv__(self, other)	定义整数除法的行为：//
__mod__(self, other)	定义取模算法的行为：%
__divmod__(self, other)	定义当被 divmod() 调用时的行为
__pow__(self, other[, modulo])	定义当被 power() 调用或 ** 运算时的行为
__lshift__(self, other)	定义按位左移位的行为：<<
__rshift__(self, other)	定义按位右移位的行为：>>
__and__(self, other)	定义按位与操作的行为：&
__xor__(self, other)	定义按位异或操作的行为：^
__or__(self, other)	定义按位或操作的行为：|
反运算
__radd__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rsub__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rmul__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rtruediv__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rfloordiv__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rmod__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rdivmod__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rpow__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rlshift__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rrshift__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rxor__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__ror__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
增量赋值运算
__iadd__(self, other)	定义赋值加法的行为：+=
__isub__(self, other)	定义赋值减法的行为：-=
__imul__(self, other)	定义赋值乘法的行为：*=
__itruediv__(self, other)	定义赋值真除法的行为：/=
__ifloordiv__(self, other)	定义赋值整数除法的行为：//=
__imod__(self, other)	定义赋值取模算法的行为：%=
__ipow__(self, other[, modulo])	定义赋值幂运算的行为：**=
__ilshift__(self, other)	定义赋值按位左移位的行为：<<=
__irshift__(self, other)	定义赋值按位右移位的行为：>>=
__iand__(self, other)	定义赋值按位与操作的行为：&=
__ixor__(self, other)	定义赋值按位异或操作的行为：^=
__ior__(self, other)	定义赋值按位或操作的行为：|=
一元操作符
__neg__(self)	定义正号的行为：+x
__pos__(self)	定义负号的行为：-x
__abs__(self)	定义当被 abs() 调用时的行为
__invert__(self)	定义按位求反的行为：~x
类型转换
__complex__(self)	定义当被 complex() 调用时的行为（需要返回恰当的值）
__int__(self)	定义当被 int() 调用时的行为（需要返回恰当的值）
__float__(self)	定义当被 float() 调用时的行为（需要返回恰当的值）
__round__(self[, n])	定义当被 round() 调用时的行为（需要返回恰当的值）
__index__(self)	1. 当对象是被应用在切片表达式中时，实现整形强制转换 2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 __index__ 3. 如果 __index__ 被定义，则 __int__ 也需要被定义，且返回相同的值
上下文管理（with 语句）
__enter__(self)	1. 定义当使用 with 语句时的初始化行为 2. __enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定
__exit__(self, exc_type, exc_value, traceback)	1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么 2. 一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作
容器类型
__len__(self)	定义当被 len() 调用时的行为（返回容器中元素的个数）
__getitem__(self, key)	定义获取容器中指定元素的行为，相当于 self[key]
__setitem__(self, key, value)	定义设置容器中指定元素的行为，相当于 self[key] = value
__delitem__(self, key)	定义删除容器中指定元素的行为，相当于 del self[key]
__iter__(self)	定义当迭代容器中的元素的行为
__reversed__(self)	定义当被 reversed() 调用时的行为
__contains__(self, item)	定义当使用成员测试运算符（in 或 not in）时的行为

若需要示例请戳：Python魔法方法指南

结语

关于继承，重写，静态类，异常捕获和处理、面向对象等其它内容因篇幅过长后续再补（到这里储备的基础知识应该够用了，后续若用到一些科学计算的库在现学吧）。

接下来一段时间专注在算法&数据结构，准备沉淀几个月迈过这道坎。当中代码为加深了解尽可能写两套（C#和Python），感兴趣的朋友可以关注。

谢谢大家。