Python学习

前言

Python具有高支持性。其程序代码是公开的，全世界有无数的人在搜索其漏洞并修复它。
Python提供内置的解释器，不需要额外的解释器。用户也需要完整的程序模块才能测试， 只需要在解释器内编写测试的部分即可。
Python解释器非常有弹性，其允许用户嵌入C++程序代码作为扩展模块。
Python将大部分的函数以模块和类库来存储。大量的模块以标准Python函数库的形式与解释器一起传输。用户可以将程序分割成数个模块，然后在不同的程序中使用。
除了可以在多种操作系统中运行之外，不同种类的操作系统使用的程序接口也是一样的。

一.基础语法

1.程序结构

• 缩进分层

  与其他常见语言不同，Python的代码块不使用大括号来控制类，函数及其他逻辑判断。Python用缩进分层来写模块。

  if True:
      print ("牧童骑黄牛")  
      print ("歌声振林樾")  
  else:    
      print ("意欲捕鸣蝉")  
      print ("忽然闭口立")

2.输入输出

• 输入

  x= input ("请输入最喜欢的水果：")

• 输出

  print()函数可以输出格式化的数据，与C/C++的printf()函数功能和格式相似。
  print()函数的基本语法格式如下：

  print(value,...,sep=' ',end='\n')

(1)value是用户要输出的信息，后面的省略号表示可以有多个要输出的信息。
(2)sep用于设置多个要输出信息的分隔符，其默认的分隔符为空格
(3)end用于结束符，其默认为换行
注意：如果输出的内容既包括字符串，又包含变量值，就需要将变量值格式化处理.
如

print("x = % d" % x) #正确  
print("x = % d", x) #错误

3.变量

• 可以直接声明变量名称，不必声明变量类型
• 不需要声明，但必须在使用之前进行赋值
• 允许用户同时为多个变量赋值

4.数据类型

• 数字类型包括4种(int,float,bool,complex)

注意：数值之间可以通过运算符进行运算操作

1/2   #除法，得到一个浮点数0.5  
1//2   #除法，得到一个整数0  
2 ** 10  #乘方，得到1024

• 字符串类型（使用单引号，双引号或三引号包含起来，第一个字符的索引值永远为0，字符串长度超过一行时，必须使用三引号)

• 集合类型（Sets）
  Sets是一个无须不重复元素的集。主要用于自动清除重复的元素，用大括号

  goods = {'like','love','affection','be fond of','be keep on'}  
  print(goods)  #输出集合内容  
  goods = set()  #创建一个空集合，必须使用set()函数

• 列表类型（List）
  列表的元素类型可以不相同，甚至可以嵌套，用中括号

  b = [1,2,3,4]  
  b[0]  #返回第一个，1  
  b[-1]  #返回最后一个列表元素，4

常见操作：

(1)查找。index(c)返回c的索引值
(2)修改。a[1] = “黑色”，将a列表的第二个元素改为黑色
(3)插入。a[2:] = “烟灰色”,300, 将a列表的第三个元素后加上”烟灰色”,300
(4)删除。del a[1],删除a列表的第二个元素。若要一次性删除所有元素用del a[:]即可
(5)列表操作符+和()*

内置函数：len(),max(),min(),list()
列表方法：在Python解释器中输入dir([])即可查看

(1)添加。添加元素用append(object)在列表尾加上新元素object。添加列表用extend(list)
(2)清空。clear()类似于del a[:]
(3)复制。copy()
(4)计数。count(value)对列表中的相同元素值value计算其个数
(5)查找index(value)
(6)插入。在索引值为index的元素前插入insert(index,object)
(7)删除。删除索引值为index的元素，如果没有指定的索引值则删除最后一个元素；删除元素为value:remove(value)
(8)反序。reverse()
(9)排序。sort()将元素按从小到大进行排序

• 元组类型（Tuple）
  Tuple是有序对象的集合，不可以增加，删除，修改，用小括号（小括号也可以省略）

常用操作：

(1)创建。如a = (100,)如果创建对象只有一个，其后必须加一个逗号
(2)不可修改。
(3)删除。若要删除第二个元素，则输入a = a[0],a[2],a[3]后按回车输出a即可
(4)获取。a[0]即可获取第一个元素值
(5)组合。c = a + b
(6)删除整个元组。del a

内置函数：len(),max(),min(),sum()

• 字典类型（Dictionary）
  非常常用，元素由key:value组成；同一个字典里，key必须不同，若相同只有最后一个有效；列表不能当key；用大括号

  >>> dd={"名称":"冰箱","产地":"beijing"}
  >>> dd
  {'名称': '冰箱', '产地': 'beijing'}

常用操作：

(1)获取。使用key作为索引，如dd[“名称”]
(2)修改。dd[“名称”] = “锅巴”
(3)删除。del dd[“名称”]

内置函数：len(),str()将字典元素转化为可打印的字符串形式,type()返回输入的变量类型
内置方法：在Python解释器中输入dir([])即可查看

(1)clear():清除字典中的所有元素 copy()
(2)get(k,d)

>>> dd={"名称":"冰箱","产地":"beijing"}
>>> dd
{'名称': '冰箱', '产地': 'beijing'}
>>> 
>>> 
>>> dd.get("名称","错误")
'冰箱'
>>> dd.get("价格","错误")
'错误'

(3)keys():返回以字典的所有key值为元素的一个列表
(4)values():返回以字典的所有value值为元素的一个列表
(5)popitem():删除字典的最后一个元素
(6)setdefault(k,d)与get(k,d)类似不同在于，若k不存在，返回d,并将新的k:d添加到字典中。
(7)update(E)E是字典对象，将E添加到字典中

5.运算符与优先级

• 算术运算符

• 比较运算符

• 赋值运算符

• 逻辑运算符（布尔and,or,not）

  True or 18 #返回True
  False or 0 #返回0 
  10 or 15 #返回10 
  True and 18 #返回18
  False and 18 #返回False
  10 and 15 #返回15
  not(10 and 15) #返回False

• 位运算符

• 成员运算符（in，not in）x in y:x在y序列中

• 身份运算符（is，not is)a is b:a和b引自一个对象

• 优先级
  一个特殊的运算符lambda

  a=lambda x,y:x +y
  print (a(3,4)) #返回结果为7

6.字符串

常用操作

(1)访问。用方括号
(2)分割指定范围。a[x:y],x为开始的索引值，y为结束的索引值。
(3)更新。字符串的字符不能直接修改，可间接修改更新。
(4)转义字符的使用。

6.1字符串运算符

• 加号（+）。连接
• 乘号（*）。将一个字符串的内容复制多次
• 逻辑（>,<,==）。比较大小
• in和not in。判断某个字符是否存在于某个字符串中

6.2格式化字符串

%左边放置带格式化的字符串，右边放置希望格式化的值。

>>> a = "今天是我在%s待的第%d天"
>>> b = ('家',4)
>>> c = a % b
>>> c
'今天是我在家待的第4天'

注意：字符串包含百分号应该写%%或在print中写（c+”%”）

6.3内置方法

• capitalize(),将第一个字符转化为大写，其他字符串转化为小写

• low(),将所有大写转化为小写

• swapcase(),小写变大写，大写变小写

• count(),统计某个子字符串出现的次数。如str.count(sub,start=0,end=len(string))sub为被搜索的子字符串,star和end为开始和结束的位置。

• find(),判断字符串中是否包含要找的子字符串，若有返回其索引值，若没有就返回-1

• index(),同find(),不同在于index()找不到时报异常。

• isalnum(),判断是否只由字母或数字组成，若是返回True,否则返回False

• isalpha(),判断是否只由字母或汉字组成

• isdigit(),判断是否只由数字组成

• join(),以指定字符连接生成以一个新的字符串

  >>> s = "*"
  >>> a=("我","想","出去","玩")
  >>> print(s.join(a))
  我*想*出去*玩

• max(),min()

• replace(),讲旧字符串替换成新字符串，如str.replace(old,new,sum)sum为替换个数

• title(),返回标题化的字符串

二.控制结构

1.赋值语句

• 基本赋值。注意：在python中赋值语句不能被当作表达式，不能返回值。

  >>> if(a=1)
  SyntaxError: invalid syntax

• 序列赋值。一次性给多个变量赋不同的值

• 链式赋值。将同一个值赋给多个变量

2.程序结构

• for语句。for <variable> in <sequence>:
• python无switch…case语句
• continue语句将跳过当前循环块中的剩余语句
• 若循环被break语句终止，那么后面的else语句不会被执行
• pass语句。没用，为了保持程序语句的完整性，为占位语句

三.函数

1.常见内置函数

• abs(x):返回x的绝对值
• chr(i):返回数值i对应的ASCII字符，ord()函数作用相反
• complex(x,y):创建一个复数
• dir(object):返回object对象的属性名称列表
• divmod(a,b):以元组形式返回ab的商以及余数
• pow(x,y,z):没有z时，返回x的y次方；有z时返回x的y次方再除以z的余数。比pow(x,y)%z有效

2.函数的定义

语法如下：def 函数名称（参数1，参数2）：

>>> def s (x,y):
	return x-y

>>> s(10,4)
6

3.可变参数

用户在声明参数时不确定需要使用多少个参数时，就可以使用可变参数。语法如下：def functionname(formal_args,*var_args_tuple):

def fruits (a,*args):
	print(a)
	for b in args:
		print("可变参数为：",b)
	return
print("不带参数")
fruits("西瓜")
print("带2个可变参数")
fruits("西瓜","苹果",15)
print("带6个可变参数")
fruits("西瓜","苹果",15,"橙子",3,"葡萄",4)  
>>> 
============= RESTART: D:/Program Files/Python 3.7/Demo/可变参数.py =============
不带参数
西瓜
带2个可变参数
西瓜
可变参数为： 苹果
可变参数为： 15
带6个可变参数
西瓜
可变参数为： 苹果
可变参数为： 15
可变参数为： 橙子
可变参数为： 3
可变参数为： 葡萄
可变参数为： 4
>>>

*args代表一个元组对象，**args代表一个字典对象

4.返回函数

函数不仅可以作为其他函数的参数，还可以作为其他函数的返回结果
如果在一个内部函数里对外部作用域（不是全局作用域）的变量进行引用，内部函数就称为闭包

>>> def f1(n):
	def f2(x):
		return (x+n)
	return f2

>>> p1 = f1(2)
>>> print(p1(6))
8
>>>

函数f2对函数f1的参数n进行了引用，将带参数的函数f1给一个新的函数p1.当函数f1的生命周期结束时，已经引用的变量n存放在函数f2中，依然可以调用。
注意：尽量避免在闭包中引用循环变量

5.递归函数

汉诺塔问题：有三根柱子，首先在第一根柱子从下向上按照大小顺序摆放64片圆盘；然后将圆盘从下开始同样按照大小顺序摆放到另一根柱子上，并且规定小圆盘上不能摆放大圆盘，在三根柱子之间每次只能移动一个圆盘；最后移动的结果是将所有圆盘通过其中一根柱子全部移到另一根柱子上，并且摆放顺序不变。

def move(n,a,b,c):  #n为需要移动的圆盘的个数
    if n==1:
        print (a,'-->',c)
        return
    else:
        move(n-1,a,c,b)   #首先需要把（n-1）个圆盘移动到b
        move(1,a,b,c)     #将a的最后一个圆盘移动到c
        move(n-1,b,a,c)   #再将b的（n-1）个圆盘移动到c
    move(4,'A','B','C')

防止栈溢出通过尾递归优化（指在函数返回时调用函数本身，并且return语句不能包含表达式），使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

def f (n):
	return f1(n,1)
def f1(num,product):
        if num ==1:
                return product
        return f1(num -1,num * product)
>>> f(6)
720
>>>

6.匿名函数

例如：f=lambda x,y:x+y Python将使用lambda创建一个匿名函数
优点：

• 执行一些脚本时，使用lambda可以省去定义函数的过程
• 不需要考虑命名的问题
  规则：
• 若只有一个表达式，则必须有返回值
• 可以没有参数，也可以有一个或多个参数
• 不能有return

  >>> g=lambda x:x**2
  >>> print(g)
  <function <lambda> at 0x0000026EC462B1E0>
  >>> print(g(6))
  36
  >>>

7.偏函数

通过设置参数的默认值，可以降低函数的调用的难度。
functools.partial就是帮助用户创建偏函数的。

>>> from functools import partial
>>> int2 = partial(int,base=2)  #将2进制转化为10进制
>>> int2('1001000')
72
>>> int2('1000011')
67
>>>

四.对象与类

类是一群对象的集合。对象是类的实例化。对象分为静态和动态特征两种。变量即为静态特征又称属性，方法即为动态特征又称行为。一个对象由一组属性和一系列的方法组成。
面向对象的特征：封装性，继承性，多态性
类的定义，构造方法，创建与C语言C++都十分类似。

1.创建类

下面示例创建一个简单的类Fruits

class Fruits:  #定义类名为Fruits
"这是一个定义水果类的例子"  
fruCount = 0  #初始化变量fruCount为0  

def displayFruits(self)：#定义类的函数displayFruits，在python中称为方法.self代表类的实例即为对象    
    Fruits.fruCount += 1  
    print("这是一个水果类的例子")

2.构造方法

Python使用init()函数作为对象的构造方法，当用户要在对象内指向对象本身时，可以使用self.(相当于C++中的this)
举一个构造函数的简单例子

class Student:
    name = ''
    age = 18
    num = 0
def _init_(self,n,a,u):  #构造函数初始化
    self.name = n
    self.age = a
    self.num = u
def displayStudent (self):  
    print("学生的姓名为%s年龄为%d学号为%d" % (self.name,self.age,self.num))
s = Student('mary', 18, 0) #定义变量
s.displayStudent()   #调用displayStudent函数输出

3.重载运算符

如果要在Python解释器内使用运算符函数，首相必须加载operator模块，然后调用operator模块的运算符函数
如下：

>>>import operator  
>>>operator.add(100,200)
300

4.类的继承

与C++类似，派生类的构造方法必须调用基础类的构造方法，并使用完整的基类名称

>>>Class Person(Student):def _init_(self,name,sex,phone):     #派生类Student的构造方法  
Student._init_(self,name,sex,phone)    #调用基类的构造方法

python同样支持类的有限多继承

5.类的多态

与C++类似，所谓类的多态，就是指类可以有多个名称相同，参数类型却不同的函数。因为pyth函数的参数不必声明数据类型，因此它并没有明显的多态特性。但是pyth利用动态数据类型忍让可以处理对象的多态。pyth必须等到运行该函数的时候才知道该函数的类型，这种特性称为运行期绑定
与C++不同的是，C++将多态程为方法重载，允许类内有多个名称相同，参数却不同的函数存在。但是python不允许这样子，如果用户在Python的类内声明多个名称相同，参数却不同的函数，那么python会使用类内的最后一个声明的函数。

6.类的封装

python类中所有的变量和方法都是公有的，如果要做到类的封装，使其成为私有，必须遵循以下原则

• 属性名称的第一个字符是单下划线，那么该属性视为类的内部变量，外部的变量不可以引用该属性
  以上原则只是参考，python属性仍是公有的。