Python学习记录

Python

基础语法

函数

可以重复使用，可以提高应用的模块性和代码重复利用率
定义函数规则：
以  def  开头，后接函数标识符和圆括号()
任何传入参数和自变量必须在圆括号中间，圆括号之间可以用于定义参数
函数内容以冒号起始，并且缩进
return[表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None

语法：
def functionname( parameters ):
	"函数_文档字符串"
	function_suite
	return [expression]

函数的调用

def printme(str):
	"打印任何传入的字符串"
	print(str)
	return

printme("我要调用用户自定义函数");
printme("再次调用");
printme(str="my string")

按值传递参数和引用传递参数

# 可写函数说明
def changeme(mylist):
	"修改传入的列表"
	mylist.append([1,2,3,4])
	print("函数内取值：", mylist )
	return

# 调用changeme函数
mylist = [10,20,30]
changeme(mylist)
print("函数外取值：", mylist )

参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
关键字参数
def printinfo(name,age):
	"打印任何传入的字符串"
	print("Name", name)
	print("Age", age)
	return
	printinfo( age=18, name="zhangs" )
默认参数
不定长参数
def functionname([formal_args,] *var_args_tuple ):
	"函数_文档字符串"
	function_suite
	return [expression]
加了星号(*)的变量名会存放所有未命名的变量参数

#可写函数说明
def printinfo( arg1, *vartuple):
	"打印任何传入的参数"
	print("输出：")
	print(arg1)
	for var in vartuple:
		print(var)
	return

printinfo(10)
printinfo(70,60,50)

匿名函数

python使用lambda来创建匿名函数
lambda只是一个表达式，函数体比def简单
lambda主体是一个表达式，不是代码块，仅仅能在lambda表达式中封装有限的逻辑
lambda拥有自己的命名空间
语法
lambda [arg1,arg2,.....argn]:expression
实例
#可写函数说明
sum = lambda arg1, arg2: arg1 + arg2

#调用sum函数
print("相加后的值为：", sum(10, 20))

return语句
退出函数，不带参数值的return语句返回None

变量作用域(全局变量    局部变量)
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
实例
total = 0 #这是一个全局变量
#可写函数说明
def sum(arg1, arg2):
	"返回2个参数的和."
	total = arg1 + arg2 # total在这里是局部变量
	print("函数内是局部变量：", total)
	return total

sum(10, 20)
print("函数外是全局变量：", total)

类

什么是面向对象编程？
面向对象术语
1、类（class）
用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
2、方法
类中定义的函数
3、类变量（属性）
类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用，类变量也称作属性。
4、数据成员
类变量或者实例变量用于处理类及其实例对象的相关的数据
5、方法重写
从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖(override),也称为方法的重写
6、实例变量
定义在__int__方法中的变量，只用于当前实例的类
7、继承
一个派生类(derived class)继承基类(base class)的字段和方法。
继承也允许把一个派生类的对象作为一个基类对象对待,以普通的类为基础建立专门的类对象。
8、实例化
创建一个类的实例，类的具体对象。一个类可以实例化出无数个对象
9、对象
通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法
10、多态
不同类的对象使用同样的操作
11、封装
对外部世界隐藏对象的工作细节

类的定义语法
class ClassName:
	语句1
	...
	语句n
----------------
注：
1、类定义与函数定义(def语句)一样，只有在被执行才会起作用
	在定义阶段只是语法检查
2、类是属性和方法的组合，所以语句1可能是内部变量(数据、属性)的定义和赋值语句，也可能是内部方法(函数)的定义语句
	一个对象的特征称为”属性“
	一个对象的行为称为”方法“
	代码层面，属性就是变量，方法就是函数
3、进入类定义时，就会创建一个新的命名空间，并把它用作局部作用域
4、正常离开（从结尾出）类定义时，就会创建一个类对象
实例
class MyClass:
	"""定义一个MyClass类"""
	i = 12345
	def func(self):
		return 'hello world'


注：
类包含属性和方法
类属性和实例属性
方法： 定义在类中的函数
func表示定义了一个名为func的"实例方法"，实际上就是一个稍微特殊点的函数(方法的第一个参数必须为self)

类对象
支持两种操作（属性引用   实例化）
实例化：使用instance_name = class_name()的方式实例化，实例化操作创建该类的实例(格式：实例对象名 = 类名()，实例对象名是我们自己定义的)
class MyClass:
	'''定义一个MyClass类'''
	i = 12345

	def func(self):
		return 'hello world'
#实例化一个类
my_class = MyClass()
print(my_class)


属性引用：使用class_name.attr_name的方式引用类属性(类名.属性名)
class MyClass:
	'''定义一个MyClass类'''
	i = 12345
	def func(self):
		return 'hello world'
print(MyClass.i)   # 引用属性
print(MyClass.func)  #引用实例方法：实例方法可以被这样引用，但是这样引用无意义

# 类属性也可以被赋值，因此可以通过赋值来更改类属性的值
MyClass.i = 123
print(MyClass.i)

实例对象
基于类创建的一个具体的事物
通过类产生实例对象的过程称为实例化
格式：     实例对象名 = 类名()
实例对象是类对象实例化的产物，实例对象仅支持一个操作：属性引用
"实例对象名.属性名"
"实例对象名.方法名()"
=====================================================================
实例
class MyClass:
    """定义一个MyClass类"""
    i = 12345

    def func(self):
        return 'hello world'


# 第一个实例对象
my_class = MyClass()
print(id(my_class))
print(my_class.i)  # 引用类属性
print(my_class.func())  # 引用实例方法

# 第二个实例对象
my_class1 = MyClass()
print(id(my_class1))
# 类属性重新赋值
my_class1.i = 123
print(my_class1.i)  # 引用类属性
print(my_class1.func())  # 引用实例方法

# 第三个实例对象
my_class2 = MyClass()
print(id(my_class2))
print(my_class2.i)
print(my_class2.func())  # 引用实例方法
============================================================================
注：
类在使用前必须先实例化，并将实例赋值给一个变量(得到实例对象)

self参数
1、在定义实例变量、实例方法时的第一个参数必须是self
2、self在定义时需要定义，但是在调用时会自动传入
3、self代表的当前的实例对象本身
================================
class MyClass:
    """定义一个MyClass类"""
    i = 12345

    def func(self):
        print("self参数：", self)
        return 'hello world'

a = MyClass()
print("实例对象：", a)
a.func()

b = MyClass()
print("实例对象：", b)
b.func()
================================================
class Ball:
    def setname(self, name, age):
        self.name = name
        print(age)

    def kick(self):
        return "我叫%s" % self.name

a = Ball()
b = Ball()
c = Ball()

a.setname("A", 1)
b.setname("B", 2)
c.setname("C", 3)

print(a.kick())
print(b.kick())
print(c.kick())
=========================================
注：
在方法中定义的参数，一般来说只能在当前方法中使用(作用域)
如果想要一个方法中的参数能在其他方法中使用，那么就可以使用"self."来将这个参数变成一个实例变量(实例变量后面介绍，这里主要是遇到了这种写法)

类变量
该类所有实例对象共享的属性（也叫”类属性“）
	⑴类属性是所有实例都共用的：所有实例都可以调用这个类属性
    ⑵在类中任意地方(所有方法中)都可以使用"类名.类属性名"来调用类属性
    ⑶在类外任意地方都可以使用"类名.类属性名"或"实例名.类属性名"来调用类属性
=================================================
class Car():
    """这是一个汽车类"""
    brand = "宝马"

    def run(self, s):
        # 类中调用类属性：类名.属性名
        print("当前车型为：%s,当前行驶速度：%s KM/S" % (Car.brand, s))

a = Car()
# 类外调用类属性：实例名.属性名
print(a.brand, id(a.brand))
a.run(110)

b = Car()
print(b.brand, id(b.brand))
b.run(200)
===============================================

实例变量
1、是每个实例都独有的数据（也可以叫"实例属性"）
2、实例变量是定义在__init__方法中的
	①__init__()方法也是类中的一个方法，因此其第一个参数也必须是self
	②实例变量是每个实例对象独有的，因此在定义实例变量时，必须是：self.实例变量名 = 外部形参名(通过self来绑定当前实例对象) 
	③在类中任意地方(所有方法中)都可以使用"self.实例属性名"来调用实例属性
	④在类外任意地方都可以使用"实例名.实例属性名"来调用实例属性
=================================================================
class People():
    country = "china"   # 类属性country，是所有实例共有的

    def __init__(self, name):
        self.name = name     # 实例属性name，是每个实例独有的

    def speak(self, age):
        # 类中调用类属性：类名.属性名
        # 类中调用实例属性：self.属性名
        print("我的名字是：%s,来自：%s,年龄是：%s" % (self.name, People.country, age))

# 实例化类时传入实例变量值
a = People("Tom")
a.speak(11)

b = People("Jack")
b.speak(12)
=============================================================
注：
一个类中存在实例变量(定义了init方法且init方法中存在形参)时，那么在实例化类时就需要传入对应的实参，否则会报错
类中是不可能出现实例对象名的
	类中的self参数就相当于一个形参，当类实例化后，实例对象就相当于self参数的实参
	哪个实例对象在调用，self参数就表示哪个实例对象
在类中调用实例属性时都必须使用"self.实例属性名"的方式来调用，这样才能通过self参数来确定当前是哪个实例对象在调用	

类变量与实例变量
#在调用一个类中的属性时，Python会按照一定的顺序去查找这个属性：先在当前实例中找，有就用当前实例中的，如果没有就找类中的
==================================================================
class C:
    count = 0

a = C()
b = C()
c = C()
print(a.count, b.count, c.count)  # output:0,0,0

a.count += 10  # 实例对象调用类属性
print(a.count, b.count, c.count)  # output:10,0,0

C.count += 100  # 类对象调用类属性
print(a.count, b.count, c.count)  # output:10,100,100
================================================================
注：
通过"实例对象名.属性名"来覆盖类属性，只会影响到当前实例对象，不会影响到其他实例对象中的类属性
通过"类名.属性名"来覆盖类属性，会影响到所有实例的类属性