极客营python学习

详细的教程在python基础的教程

Anaconda环境安装

这个比原生的python用起来更方便
可以去清华镜像上下：清华大学开源软件镜像站

python语法的一些笔记

Python 是动态类型编程语言
Python 即可以面向对象编程，也可以面向函数编程
面向对象思想：创建一个汽车，然后调用汽车 run 方法
面向函数思想（过程）：写个函数，函数里面让 4 个轮子扛着一个沙发同样的速度跑起来

变量和简单的赋值语句

对象和引用

Python 中，一切皆对象。每个对象由：标识（identity）、类型（type）、value（值）组成。对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作。

标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数id(obj)可返回对象 obj 的标识。
类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的操作。可以使用 type(obj)获得对象的所属类型。
值表示对象所存储的数据的信息。使用 print(obj)可以直接打印出值。
在 Python 中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。变量通过地址引用了“对象”。

变量位于：栈内存。
对象位于：堆内存。
● Python 是动态类型语言
变量不需要显式声明类型。根据变量引用的对象，Python 解释器自动确定数据类型。
● Python 是强类型语言
每个对象都有数据类型，只支持该类型支持的操作。

代码的组织和缩进

很多编程语言通过字符(例如：花括号{})、关键字(例如：begain/end)来划分代码块。同时，在配合代码的缩进增加可读性。“龟叔”设计 Python 语言时，直接通过缩进来组织代码块。“缩进”成为了 Python 语法强制的规定。
缩进时，几个空格都是允许的，但是数目必须统一。通常采用“四个空格”表示一个缩进。目前，常用的编辑器一般设置成：tab 制表符就是 4 个空格。
Python 与 C、Java 等高级语言不同，其代码块不使用大括号{}来控制语句、函数、类的作用域。Python 采用独特的缩进来控制模块作用域。缩进的方式有二种：
● Python 编辑器自动生成缩进：每当回车时，编辑器会自动完成缩进工作。
● 人为手工代码缩进：缩进的空格数量可变，但同一函数的空格数必须保持一致。
缩进的空格数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，且必须严格的执行这种规则。

类型转换

num = input("请输入一个整数：")
int(num)
print('您输入的整数是：',num)
#输出结果虽然看上去一样，但是输出的是int类型的。

切片

切片操作是从列表 A 中获取一个子列表 B。列表 A 可以称为父列表。从 A 中获取 B，需要指定 B 在 A 中的开始索引和结束索引，因此，切片操作需要指定两个索引。对于列表的切片操作和字符串类似。切片是 Python 序列及其重要的操作，适用于列表、元组、字符串等等。切片的语法格式如下：

列表[起始偏移量 start : 终止偏移量 end [:步长 step]]

典型操作（三个量为正数的情况）：

典型操作（三个量为负数的情况）：

a=[10,20,30,40,50,60,70]
print(a[:]) #默认从列表的开始到列表结束 ，步长为 1
print(a[1:]) #从列表的索引 1 开始到结束，步长为 1
print(a[:2]) #从开始到索引 1，步长为 1
print(a[1:3]) #从列表索引 1 开始到索引 2，步长为 1
print(a[1:6:2]) #从列表索引 1 开始到索引 5，步长为 2a=[10,20,30,40,50,60,70]
print(a[-3:]) #从列表的倒数第 3 个开始到列表结束
print(a[-5:-3]) #从倒数第 5 个开始到倒数第 4 个
print(a[::-1]) #从右到左反向提取

#使用切片方法，更改字符串
mystr = 'hello world igeek and igeekhome'
oldthis=mystr[12:17]#存放igeek
newthis='replace'#存放replace
sum=len(mystr)#存放长度
print('字符串为：',mystr)
print('长度为：',sum)
newstr = ''
i = 0
while i < sum:if mystr[i:i+5] == "igeek":i += 5newstr = newstr + newthiselse:newstr = newstr + mystr[i]i += 1
print('更新的字符串为：',newstr)

数据类型

注：● Sequence 类型簇：可以将字符串看作由字符组成的序列类型，包括 String、Tuple、List 三种类型

类型转换

#类型转换
#转换为 int
print('int()默认情况下为：', int())
print('str 字符型转换为 int：', int('010'))
print('float 浮点型转换为 int：', int(234.23))
#十进制数 10，对应的 2 进制，8 进制，10 进制，16 进制分别是：1010,12,10,0xa
print('int(\'0xa\', 16) = ', int('0xa', 16))
print('int(\'10\', 10) = ', int('10', 10))
print('int(\'12\', 8) = ', int('12', 8))
print('int(\'1010\', 2) = ', int('1010', 2))#转换为 float
print('float()默认情况下为：', float())
print('str 字符型转换为 float：', float('123.01'))
print('int 浮点型转换为 float：', float(32))#转换为 complex
print('创建一个复数(实部+虚部)：', complex(12, 43))
print('创建一个复数(实部+虚部)：', complex(12))#转换为 str 字符串
print('str()默认情况下为：', str())
print('float 字符型转换为 str：', str(232.33))
print('int 浮点型转换为 str：', str(32))
lists = ['a', 'b', 'e', 'c', 'd', 'a']
print('列表 list 转换为 str:', ''.join(lists))#转换为 list
strs = 'hongten'
print('序列 strs 转换为 list:', list(strs))#转换为 tuple
print('列表 list 转换为 tuple:', tuple(lists))#字符和整数之间的转换
print('整数转换为字符 chr:', chr(67))
print('字符 chr 转换为整数:', ord('C'))print('整数转 16 进制数:', hex(12))
print('整数转 8 进制数:', oct(12))

集合操作

列表

列表创建

基本语法[]创建a = [10,20,30,40]
list()创建

a = list() #创建一个空的列表对象
b = list("gaoqi,sxt")
print(a)
print(b)

range()创建整数列表

a=list(range(3,15,2)) #从 3 开始步长是 2 及从开始每次增加 2
b=list(range(15,3,-1)) #从 15 开始每次减 1
c=list(range(3,-10,-1)) #从 3 开始每次递减 1
print(a)
print(b)
print(c)

推导式生成列表（列表生成式）

a=[x for x in range(1,5)]
b=[x*2 for x in range(1,5)]
c=[x*2 for x in range(1,20) if x%5==0 ]
d=[x for x in "abcdefg"]
print("a 列表的元素:",a)
print("b 列表的元素:",b)
print("c 列表的元素:",c)
print("d 列表的元素:",d)

a 列表的元素: [1, 2, 3, 4]
b 列表的元素: [2, 4, 6, 8]
c 列表的元素: [10, 20, 30]
d 列表的元素: [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]

列表的基本操作

列表的添加

在列表的末尾追加一个新对象，使用 append()方法。

#列表中添加元素
a=[10,20,30]
a.append(40)
print('增加元素后的列表：',a)

+运算符操作，并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

#列表使用+操作符相加
a=[10,20,30]
print('a 的地址：',id(a))
b=[40,50]
a=a+b
print('a 列表的元素：',a)
print('a 的地址：',id(a))

注意：● 通过如上测试，发现变量 a 的地址发生了变化。也就是创建了新的列表对象。

extend()方法，将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

#使用 extend()方法添加列表
a=[10,20,30]
print('a 的地址：',id(a))
b=[40,50]
a.extend(b)
print('a 列表的元素：',a)
print('a 的地址：',id(a))

使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。

#使用 insert 函数插入元素
a=[10,20,30]
a.insert(2,100) #在列表 a 的索引 2 处插入元素 100
print(a)

列表的查找

a) 通过索引直接访问元素
序列中的所有元素都是有索引的，编号从 0 开始递增，最大到列表的长度减 1。序列中的所有元素都可以通过索引访问。

如果索引是 0 或正整数，那么 Python 语言会从列表的左侧第一个元素开始获取；如果索引是负数，那么 Python 语言会从列表右侧第一个元素开始获取。序列最后一个元素的索引是-1，倒数第二个元素的索引是-2，以此类推。从右侧获取列表的值

当索引超过列表的索引范围，会抛出异常。

b) index()获得指定元素在列表中首次出现的索引

index()可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])。其中，start 和 end 指定了搜索的范围

a = [10,20,30,40,50,20,30,20,30]
print(a.index(20)) #从列表中搜索第一个 20
print(a.index(20,3)) #从索引位置 3 开始往后搜索的第一个 20
print(a.index(30,5,7)) #从索引位置 5 到 7 这个区间，第一次出现 30 元素的位置

列表的修改

修改列表中的某一个元素，可以像使用数组一样对列表中的特定元素赋值，也就是使用一对中括号指定元素在列表中的索引，然后使用赋值运算符（=）进行赋值。

列表的删除

a) del 删除
del 删除列表指定位置的元素。语法格式：del 元素。
b) pop 删除
pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。

a=[1,2,3,4,5,6]
b=a.pop() #没有指定位置，默认的是最后一个元素
print(b)
print(a)
c=a.pop(2) #删除下标为 2 的元素
print(c)
print(a)

c) remove 删除
删除首次出现的指定元素，若不存在该元素抛出异常。

列表常用的API

列表的长度、最大值和最小值
len、max 和 min 这三个函数用于返回列表中元素的数量、列表中最大值、列表中最小值。使用 max 和 min 函数要注意一点，就是列表中的每个元素值必须是可比较的。否则会抛出异常。例如，如果列表中同事包含整数和字符串类型的元素，那么使用 max、min 函数就会抛出异常。

#sort()用于对列表进行排序，调用该方法会改变原来的列表
a=[11,20,13,34,5,36,17]
a.sort()
print(a)
print('正序：',a)
a.sort(reverse=True)
print('逆序：',a) #sorted 用于对列表进行排序，生成新列表，不改变原来的列表
print('-'*5,'sorted 排序','-'*5)
a=[11,20,13,34,5,36,17]
b=sorted(a)
print('a 列表：',a) #原来列表不会被修改
print('正序 b 列表：',b)
b=sorted(a, reverse=True)
print('逆序 b 列表：',b)

元组（tuple）

元组和列表一样，也是一种序列。不同的是元组不能修改，也就是说，元组是只读的，不能对元组进行增加、删除、修改。定义元组非常简单，只需要用逗号(，)分隔值即可。

元组的创建

通过()创建元组，小括号可以省略。

#通过()创建元组
a=1,2,3,4,5,6,7 #创建一个元组 省略了括号
b=(1,2,3,4,5,6,7) #创建一个元组
c=(42,) #创建一个只有一个元素值的元组
d=() #创建一个空的元组
print(a)
print(b)
print(c)
print(d)

通过tuple()创建元组
tuple 函数的功能与 list 函数基本上是一样的。以一个序列作为参数并把它转换为元祖。如果元素的参数就是元祖，那么该参数就会被原样返回。
元组的基础操作

元组的元素不能修改
zip方法
zip(列表 1，列表 2，…)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

zip 合成元组

a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
print(list(d))

生成器推导式创建元组
从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__()方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

#生成器的使用
s = (x*2 for x in range(5))
print(s) #生成器对象
print(tuple(s)) #tuple 函数转换为元组
print(tuple(s)) #只能访问一次元素。第二次就为空了。需要再生成一次
s = (x*2 for x in range(5))
print('next 方法获取元素：',s.__next__())
print('next 方法获取元素：',s.__next__())
print('next 方法获取元素：',s.__next__())

python iter( )函数

字典（dict）

Python 内置了字典(dict)的支持，dict 全称 dictionary，在其他语言中也称为 map，使用键-值（key-value）存储，具有极快的查找速度。字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值对(key=>value)用冒号(:)分割，每对之间用逗号(,)分割，整个字典包括在花括号({})中，语法格式如下：

列表中通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。“值”可以是任意的数据，并且可重复。

a) 通过{}、 dict()来创建字典对象

b) 通过 zip()创建字典对象

C) 通过 fromkeys 创建值为空的字典

a = dict.fromkeys(['name','age','job'])
print('值为空的字典 a:',a)

通过 [键] 获得“值注意：若键不存在，则抛出异常

get 方法用于从字典中获取 key 对应的 value。优点是：指定键不存在，返回 None；也可以设定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”。

a = {'name':'gaoqi','age':18,'job':'programmer'}
print('name:',a.get('name'))
print('age:',a.get('age'))
print('job:',a.get('job'))
print('sex:',a.get('sex'))

字典的基本操作

update 方法可以用一个字典中的元素更新另外一个字典。该方法接收一个参数。该参数表示用作更新数据的字典数据源。如果 key 有重复，则直接覆盖。

a = {'name':'gaoqi','age':18,'job':'programmer'}
b = {'name':'gaoxixi','money':1000,'sex':'男的'}
a.update(b)
print(a)

可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”。

a = {'name':'gaoqi','age':18,'job':'programmer'}
del(a['name']) #del 删除元素
print(a)
b=a.pop('age') #pop 删除元素，返回对应的值
print(b)
print(a)
a.clear() #清空字典元素
print(a)

items 方法、keys 方法和 values 方法
items 方法用于返回字典中所有的 key-value 对。获得的每一个 key-value 对用一个元组表示。items 方法返回的值是一个被称为字典视图的特殊类型，可以被用于迭代（如使用在for 循环中）。items 方法的返回值与字典使用了同样的值，也就是说，修改了字典或 items方法的返回值，修改的结果就会反应在另一方法上。

keys 方法用于返回字典中所有的 key，返回值类型与 items 方法类似，可以用于迭代。

values 方法用于以迭代器形式返回字典中值的列表。

a = {'name':'gaoqi','age':18,'job':'programmer'}
print(a.items()) #字典中所有的 key-value 对
print(a.keys()) #字典中所有的 keys
print(a.values()) #字典中所有的 value
#通过遍历 key，根据 key 获取值
for key in a.keys(): print(key,':',a.get(key))

集合（set）

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对
象”，因此是不能重复的且唯一的。

a) 使用{}创建集合对象

b) 使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个.

使用 add()实现集合添加元素

使用 remove()实现集合删除指定元素、clear()清空整个集合

集合的其他操作

a = {1,3,'sxt'}
b = {'he','it','sxt'}
print('并集：',a|b)               #并集
print('并集：',a.union(b))        #并集
print('交集：',a&b)               #交集
print('交集：',a.intersection(b))#交集
print('差集：',a-b)               #差集
print('差集：',a.difference(b))   #差集

序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。

x,y,z=(20,30,10)
print('x:',x)
print('y:',y)
print('z:',z)
(a,b,c)=(9,8,10)
print('a:',a)
print('b:',b)
print('c:',c)
[a,b]=['hello','python']
print('a:',a)
print('b:',b)

enumerate()函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。enumerate() 方法的语法格式如下所示：
enumerate(sequence, [start=0])

OS模块

调用操作系统命令的模块

shutil模块(拷贝和压缩)

函数

Python 函数分为两类，即内建函数、自定义函数。

函数的定义

函数的定义非常简单，使用关键字 def 定义。函数在使用前必须定义，Python 函数的。

定义格式如下：

def 函数名 ([参数 1,参数 2…]) : 代码[return 表达式]

函数的调用

语法格式：函数名(实参 1,实参 2…)

**注意：**即使函数不需要参数，调用函数时候，也要在函数名后使用一对空的圆括号，如果不写圆括号就代表是这个函数对象本身（这是无意义的）

文档注释

注释尽管在程序中不是必需的，但却是必要的。如果没有注释，那么程序就很难被别人读懂，甚至过段时间，自己都看不明白自己编写的程序。Python 语言支持单行注释和多行注释，其中单行注释使用“#”表示，多行注释使用三个单引号或三个双引号将注释内容括起来。对于函数来说，还可以使用另外一种注释：文档注释，也有人成为“函数的注释”。

文档注释，需要在函数头(包含 def 关键字的那一行)的下一行用三个单引号或者三个双引号来实现，中间可以加入多行文字进行说明。

def print_star(n): '''根据传入的 n，打印多个星号''' print("*"*n)
#使用函数的属性"__doc__"获取文档注释
print(print_star.__doc__)
#直接使用 help 函数获取函数的文档注释
help(print_star)

变量的作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里被赋值的。变量的作用域决定了在哪一部分程序可以访问那个特定的变量的名称。Python 语言中将不同作用范围的变量分为：局部变量、全局变量。

局部变量

局部变量是指变量声明在函数内部（包含形式参数），只有在特定的过程和函数中才可以访问的变量。

全局变量

全局变量即在函数和类定义之外声明的变量。该变量供所有函数的调用，它的作用范围是整个程序。

global关键字

全局变量的作用范围是所有的函数都可用使用此变量，函数内要改变全局变量的值，使用 global 关键字。

a = 100 #全局变量
def fun1(): global a #如果要在函数内改变全局变量的值，增加 global 关键字声明 print(a) #打印全局变量 a 的值 a = 300 #修改全局变量的值 #调用函数
fun1()
print(a)

变量的就近原则

如果全局变量的名字和局部变量的名字相同，那么在函数调用变量的时候会采用 “就近原则”。

a = 100 #全局变量 a
def fun1(): a=10 #局部变量 a print(a) #打印变量 a 时候采用就近原则，则输出局部变量的 a #调用函数
fun1()

关键字参数

在 Python 中，参数传递不仅仅可以按照声明函数时参数的顺序进行传递，还可以按照形参的名称传递参数，称为“命名参数”，也称“关键字参数”。
使用按形参的名称传递参数的方式调用函数时，要在调用函数名后的圆括号里为函数的所有参数赋值，赋值的顺序可以不必按照函数声明时的参数顺序。

def fun1(a,b,c): print(a,b,c) fun1(8,9,19) #位置参数
fun1(c=10, a=20, b=30) #命名参数，参数顺序可以和声明时的顺序不一致

可变参数

在 Python 中，函数可以具有任意个参数，而不必在声明函数时对所有参数进行定义。声明函数时，如果在参数名前加上一个星号“*”，则表示将多个参数收集到一个“元组”对象中；如果在参数名前加上两个星“**”，则表示将多个参数收集到一个“字典”对象中。

def fun1(a,b,*c): #函数参数前添加一个"*",可变参数以元组形式体现 print(a,b,c)
fun1(8,9,19,20) def fun2(a,b,**c): #函数参数前添加两个"**",可变参数以字典形式体现 print(a,b,c)
fun2(8,9,name='gaoqi',age=18) def fun3(a,b,*c,**d): print(a,b,c,d) fun3(8,9,20,30,name='gaoqi',age=18)

高阶函数

所谓高阶函数，就是不光可以传递变量，还可以传递函数
面向函数编程，说白了就是把函数传来传去，函数是第一要素
面向对象编程，说白了就是把对象传来传去，对象是第一要素

map

map()函数接收两个参数，一个是函数，一个是序列，map 将传入的函数依次作用到序列的每个元素，并把结果作为新的 list 返回。

reduce

reduce 把一个函数作用在一个序列[x1, x2, x3…]上，这个函数必须接收两个参数，reduce 把结果继续和序列的下一个元素做累积计算，其效果就是：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

filter

Python 内建的 filter()函数用于过滤序列。和 map()类似，filter()也接收一个函数和一个序列。和 map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是 True 还是 False 决定保留还是丢弃该元素。

# 在一个 list 中，删掉偶数，只保留奇数
def is_odd(n): return n % 2 == 1
L=filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
print(list(L))

sorted

排序算法也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，可以直接比较，但如果是字符串或者两个 dict 呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。
通常规定，对于两个元素x 和 y，如果认为 x < y，则返回-1，如果认为 x == y，则返回 0，如果认为 x > y，则返回 1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。
Python 内置的 sorted()函数就可以对 list 进行排序：

sorter1 = sorted([1,3,6,-20,34])
print("升序排列:",sorter1)

匿名函数

在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。

f = lambda a,b,c:a+b+c
print('2+3+4 的结果:',f(2,3,4))

闭包

根据字面意思，可以形象地把闭包理解为一个封闭的包裹，这个包裹就是一个函数。在 Python 语言中，闭包意味着要有嵌套定义，内部函数使用外部函数中定义的变量，外部函数返回内部函数名。如果调用一个函数 A，这个函数 A 返回一个函数 B，这个返回的函数 B 就叫作闭包。

求两点之间的距离(闭包方式实现) ```python #使用闭包求两点之间的距离 def getDisOut(x1,y1): def getDisIn(x2,y2): return math.sqrt((x1-x2)**2+(y1-y2)**2) return getDisIn #求点(1,1)距离原点(0,0)的距离 #调用外部函数 getDisIn=getDisOut(0,0) result=getDisIn(1,1) print('点(1,1)距离原点(0,0)的距离',result) #求点(2,2)距离原点(0,0)的距离 r esult=getDisIn(2,2) print('点(2,2)距离原点(0,0)的距离',result) ```

装饰器

在上述代码中闭包的调用实在繁琐。在 python 程序中，装饰器就是一种闭包，它可以使闭包的访问方式更简单。本质上，装饰器（decorator）就是一个返回函数的高阶函数。所以，要定义一个能打印日志的装饰器（decorator）。在 Python 中使用装饰器，需要使用一个特殊的符号“@”来实现。在定义装饰器函数或类时，使用“@装饰器名称”的形式将符号“@”放在函数或类的定义行之前。

类和对象

类的定义

直接看一个例子，定义一个Student类：

#定义 Student 类
class Student: def __init__(self,name,score): #构造方法第一个参数必须为selfself self.name = name #实例属性 self.score = scoredef say_score(self): #实例方法 print(self.name,'的分数是：',self.score)
#下面写一下new一个实例对象
s1 = Student('张三',80) #s1 是实例对象，自动调用__init__()方法
s1.say_score()

创建对象

创建对象的过程称为实例化。创建对象，需要定义构造方法__init__()。构造方法用于执行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值。
__init__()的要点如下：
● 构造方法的名称是固定的，必须为：__init__()
● 第一个参数固定，必须为：self。 self 指的就是刚刚创建好的实例对象。
● 构造函数通常用来初始化实例对象的实例属性，如示上例中的构造方法就是初始化实例属性：name 和 score。
● 通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量。例如：s1 = Student(‘张三’, 80)
● 如果不定义__init__方法，系统会提供一个默认的__init__方法。如果定义了带参的__init__方法，系统不创建默认的__init__方法。
● 如果定义了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但 self 不需要传，Python 解释器自己会把实例变量传进去。

注意：Python 中的 self 相当于 C++中的 self 指针，JAVA 和 C#中的 this 关键字。Python 中，self 必须为构造函数的第一个参数，名字可以任意修改。但一般遵守惯例，都叫做 self。

#coding=utf-8
class People():
def __init__(self,name,height,weight):
self.name =name
self.height =height
self.weight = weight
def get_name(aaa): #类里面定义方法的时候第一个参数可以不是self，但是python解释器会把第一个参数当做类实例
return aaa.name
def get_height(self): #self代表的类实例本身，可以看做一个类对象变量
return self.height
p = People("zhangsan",182,60)
name = p.get_name()
print("name=",name)
height = p.get_height() #等价于 height = People.get_heght(p)
print("height=",height)
height1 = People.get_height(p) #这个时候给类函数调用显示给类方法传递了类实例
print("height1=",height1)

内置方法

私有属性和私有方法

Python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点：

通常约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
类内部可以访问私有属性(方法)。
类外部不能直接访问私有属性(方法)。
类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)。

使用方式：

#测试私有属性、私有方法
class Employee: __company = "极客程序员" #私有类属性. def __init__(self,name,age): self.name = name self.__age = age #私有实例属性 def say_company(self): #类内部可以直接访问私有属性 print("我的公司是：",Employee.__company) print(self.name,"的年龄是：",self.__age) self.__work() #类内部可以直接访问私有方法 def __work(self): #私有实例方法 print("工作！好好工作！") p1 = Employee("武松",32)
print(p1.name)
p1.say_company()
print(p1._Employee__age) #通过这种方式可以直接访问到私有属性
# print(p1.__age) #直接访问私有属性，报错
# p1.__work() #直接访问私有方法，报错

面向对象编程

这个不讲了，这个需要专门学习面向对象方法学才能非常深刻的理解这种编程思想。

正则表达式*

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。
Python 自1.5版本起增加了re 模块，re 模块使 Python 语言拥有全部的正则表达式功能。
compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。
re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。
本章节主要介绍Python中常用的正则表达式处理函数。