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
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
print ( "相加后的值为:" , sum ( 10 , 20 ) )
return 语句
退出函数,不带参数值的return 语句返回None
变量作用域( 全局变量 局部变量)
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。
实例
total = 0
def sum ( arg1, arg2) :
"返回2个参数的和."
total = arg1 + arg2
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"
def __init__ ( self, name) :
self. name = name
def speak ( self, age) :
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参数来确定当前是哪个实例对象在调用
类变量与实例变量
== == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == ==
class C :
count = 0
a = C( )
b = C( )
c = C( )
print ( a. count, b. count, c. count)
a. count += 10
print ( a. count, b. count, c. count)
C. count += 100
print ( a. count, b. count, c. count)
== == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == ==
注:
通过"实例对象名.属性名" 来覆盖类属性,只会影响到当前实例对象,不会影响到其他实例对象中的类属性
通过"类名.属性名" 来覆盖类属性,会影响到所有实例的类属性