Python入门 （一）

本文是个人python学习笔记，学习资料为廖雪峰python教程，如需更多内容，请移步廖老师官方网站。

一 安装

官网下载安装包安装，安装好之后，在命令提示符输入python进入Python交互模式：

输入exit()退出交互模式。

执行python程序文件，需先切换到文件所在目录下，再执行python 文件名:

二 语法基础

2.1 IO

输入：name=input()  ;  name=input('请输入姓名：') ；

输出：print('name',name),多个输出内容用逗号间隔；

2.2 编写基础

python用#开头标识注释单行，多行注释用三引号'''...'''，python大小写敏感。一行语句以冒号:结尾时，接下来缩进的语句是代码块，缩进使用4个空格。

字符串文本用单引号、双引号括起来，如果字符串内本身包含单引号（或双引号），则需要使用双引号（或单引号）括起字符串，如果既有'，也有“，则用\转义。

 name = input('请输入姓名:')
 print('I"am',name)
 print("I'am",name)
 print('I\'am "',name,'\"')

输出多行时，在交互模式下，用三引号'''开头，系统自动换行，提示符从>>>变为...，结束时用'''。

代码中，直接用换行，或用换行符\n。

 print('''a1
 a2
 a3''')

 print('b1\nb2\nb3')

Python中的控制None，相当于数据库中的null。

变量：变量名是大小写、数字、下划线_的组合，不能用数字开头。不需要定义变量的数据类型，变量的数据类型随赋值的数据类型而定，故变量的数据类型是可以更改的。

常量：常量用大写字母定义，但仅为书写习惯，常量的值可以改变。

list:相当于数组，但是可以追加，也可以倒叙访问元素，-1访问最后一个，-2访问倒数第二个。。。

>>> name = ['张三','李四','王五']
>>> name
['张三', '李四', '王五']
>>> name[0]
'张三'
>>> name[-1]
'王五'

>>> name.append('杨7')
>>> name[-1]
'杨7'
>>> len(name)
4

insert()将元素插入指定位置：

>>> name.insert(1,'lily')
>>> name
['张三', 'lily', '李四', '王五', '杨7']

pop()删除list末尾元素，pop(i)删除指定位置元素。

注：list元素可以是不同类型，list可以多维

tuple:元祖，初始化之后就不可以改变。当只有一个元素时需用逗号,与数学表达式区分。当元素的list时，list元素可修改。

>>> tmp = (1,)
>>> tmp
(1,)
>>> name2 = ('张三','李四',['lily','may'])
>>> name2
('张三', '李四', ['lily', 'may'])
>>> name2[2][0]='莉莉'
>>> name2
('张三', '李四', ['莉莉', 'may'])

dict:键-值（key-value）存储。使用in或get()函数判断key是否存在，通过赋值直接增加键值对，使用pop()函数删除键值对。key不能放入可变对象。

#dict初始化
score = {'张三':89,'李四':59,'王五':92}
#使用in判断key是否存在
if '张三' in score:
    print('张三的成绩是',score['张三'])
#使用get(key,returnvalue)函数判断key是否存在，存在则返回value，不存在则返回returnvalue
print('李四的成绩是:',score.get('李四','没有李四的成绩'))
print('lily的成绩是:',score.get('lily','没有lily的成绩'))

#增加一个键值对，放入杨7的成绩
score['杨7'] = 100
print('杨7的成绩是:',score.get('杨7','没有杨7的成绩'))

#删除一个键值对
print('目前成绩单是：',score)
score.pop('张三')
print('删除后的成绩单是：',score)

set:一组无序且不重复的key，创建时需用list输入集合。key不能放入可变对象。可做交集(&)、并集(|)计算。使用add()函数增加key，使用remove()函数删除key。

#set
level = set(['A','B','C','D'])
print('set level:',level)
#增加一个key
level.add('E')
print('增加后level:',level)
#删除一个key
level.remove('B')
print('删除后level:',level)

level2 = set(['A','B'])
print('set level2:',level2)

print('level与level2的交集：',level&level2)
print('level与level2的并集：',level|level2) 

除法：/  ; 地板除：// （/的整数部分） ;  取余数：%

不可变对象：str是不变对象，而list是可变对象。对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

a = 'abc'
print('替换a：',a.replace('a','A'))
print('a:',a)
b=a.replace('a','A')
print('b:',b)

2.3 字符串与编码

python 3使用Unicode编码字符串，字符串类型str，如果要在网络上传输或保存到磁盘上，需要将str变为字节为单位的bytes类型，数据用带b前缀的单引号或双引号表示。

相关函数：

• ord()：查看单个字符的编码
• chr()：把编码转化为字符

也可用十六进制表示str：

>>> '\u597d'
'好'
>>>

• encode()：将Unicode编码的str编码为指定的bytes。（中文无法用ascii编码）

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '大家好'.encode('utf-8')
b'\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd'

• decode():将网络或磁盘上读取的字节流转变为str

>>> b'ABC'.decode('utf-8')
'ABC'
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd'.decode('utf-8'，errors='ignore')
'大家好'

• len()：计算str包含的字符，或bytes包含的字节数

>>> len(b'ABC')
3
>>> len('ABC')
3
>>> len('大家好')
3
>>> len(b'\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd')
9
>>> len('大家好'.encode('utf-8'))
9

.py文件包含中文时，需要在文件开头注释使用utf-8编码，并将文件保存为UTF-8 without BOM编码格式：

# -*- coding: utf-8 -*-

占位符：

使用%做占位符：

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

>>> print('%s=%d' % ('1+2',3))
1+2=3

format():逐一替换字符串占位符{0},{1}...

>>> '{0}={1}'.format('1+2',3)
'1+2=3'

2.4 条件判断

遇到第一个为true的判断之后，执行相应的程序块，后续的elif、else将不再执行。

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

2.5 循环

for i in ...:

input = input('请输入数值：')
max = int(input)
#range(max)生成0到max-1的整数序列，再通过list()转化为list
list = list(range(max))
print(list)
sum = 0
for i in list:
    sum = sum + i
print(sum)

while ...:

input = input('请输入数值：')
max = int(input)
#range(max)生成0到max-1的整数序列，再通过list()转化为list
list = list(range(max))
print(list)
sum = 0
n =
while n < len(list):
    sum = sum + list[n]
    n = n + 1
print(sum)

三 函数

可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”

• 函数定义：def定义，执行之return返回，若不写return，则返回None。交互环境调用时，需要先切换到源程序文件所在目录，执行from abstest import my_abs，然后再调用。

def func1(x):
    return x*x

• 空函数：如果还没想好代码怎么写，可以用pass占位符，避免运行时的语法错误

def func1(x):
    pass

• 参数检查：可使用isinstance()做参数的数据类型检查
• 返回多个值：返回一个元组tuple，而多个变量可以同时接收一个tuple，按位置赋给对应的值

 #一元二次方程求解
 def quadratic(a, b, c):
 #b*b也可以写成b**2，表示b的2次方
     p = b*b - 4*a*c
     if p >=0:
         aws = math.sqrt(p)/(2*a)
         aws1 = (-1)*b/(2*a) + aws
         aws2 = (-1)*b/(2*a) - aws
         return aws1,aws2
     else:
     #共轭复根
         aws = math.sqrt(-1*p)/(2*a)
         aws1 = str((-1)*b/(2*a)) + '+i'+ str(aws)
         aws2 = str((-1)*b/(2*a)) + '-i'+ str(aws)
         return aws1,aws2

 print(quadratic(3, 3, 1))
 print(quadratic(1, 3, -4))

•  参数：位置参数、默认参数（调用时按顺序赋值，也可以写上参数名）、可变参数（参数前面加了一个*号，在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。实参如果是list或tuple，可在前面加个*号，把list或tuple的元素变成可变参数传进去）、关键字参数（关键字参数前面加**表示，允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict）、命名关键字参数（可以传入任意不受限制的关键字参数，同时显示关键字参数名称。*，*后面的参数被视为命名关键字参数）、参数组合（参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数）

 #-------可变参数  求平方和--------
 def cal(*num):
     sum = 0
     for n in num:
         sum = sum + n**2

     return sum

 #调用时参数可变
 print(cal())
 print(cal(1,2))
 print(cal(1,2,3))

 #实参为list的调用方式
 list = [1,3,5]
 print(cal(*list))

#--------关键字参数-----------
def person(name,sex,age=20,**kw):
#kw在函数内部为dict
    print('name:',name,'sex:',sex,'age:',age,'other:',kw)

#调用时可传入0或任意个含参数名的参数,age为默认参数。kw也可以是dict，调用时传**kw
person('甲','F',city='beijing',grade = 3)
person('甲','F',30,city='beijing',grade = 4)

 #-------------命名关键字参数-------------
 #city,grade为命名关键字参数，使用标识符,*,
 def person1(name,sex,*,city,grade):
     print('name:',name,'sex:',sex,'city:',city,'grade:',grade)

 #调用时命名关键字参数必须传入参数名,用来和位置参数区别
 person1('甲','F',city='beijing',grade = 3)

 #前面有可变参数时，不需要再使用标识符,*,
 def person2(name,sex,*args,city,grade):
     print('name:',name,'sex:',sex,'args:',args,'city:',city,'grade:',grade)

 person2('乙','F',15,20,city='beijing',grade = 3)

 #命名关键字参数有缺省值的，可以简化调用
 def person3(name,sex,*,age = 20,city,grade):
     print('name:',name,'sex:',sex,'age:',age,'city:',city,'grade:',grade)
 #调用时，age有缺省值，可以不给出
 person3('丙','F',city='beijing',grade = 3)

对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

    递归函数：递归的函数调用通过栈实现，如果调用次数过多会导致栈溢出，python解释器没有对尾递归（在函数返回的时候，调用自身本身，并且，return语句不能包含表达式）进行优化，故python即便使用了尾递归，仍然会栈溢出。

 #汉诺塔问题
 def hanoi(n,a,b,c):
     if n ==1 :
         print(a,'->',c)
     else:
         hanoi(n-1,a,c,b)
         print(a,'->',c)
         hanoi(n-1,b,a,c)

 hanoi(3,'A','B','C')

四 高级特性

4.1 切片

list、tuple、字符串都可以切片，从而简化代码。例：[0:3]表示取索引0、1、2；默认从0开始，所以也可以写为[:3]；[1:3]表示取1、2；[-2:]表示取-2，-1；[-2]表示取-2。

range()可创建一个整数列表，一般用在for循环中。range(start, stop[, step])，计数从start开始，默认为0，计数到stop-1，不包含stop，step默认为1。

 #去除字符串首尾的空格
 def trim(s):
     while s[0] == ' ':
         s = s[1:]
         if len(s) ==0:
             return s
     while s[-1] == ' ':
         s = s[:-2]
         if len(s) ==0:
             return s
     return s

4.2 迭代

判断对象是否可迭代：

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

迭代方式：

dict：默认迭代key：for key in d；迭代value：for value in d.values()；同时迭代key-value：for k, v in d.items()

字符串：for ch in 'ABC'迭代每一个字符

Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：for i, value in enumerate(['A', 'B', 'C'])

也支持同时引用了两个变量：for x, y in [(1, 1), (2, 4), (3, 9)]

 #迭代查找一个list中最小和最大值，并返回一个tuple
 def findMinAndMax(L):
     min = L[0] if len(L) != 0 else None
     max = L[0] if len(L) != 0 else None
     if len(L) == 0:
         return (min,max)
     else:
         for i in L:
             if i > max:
                 max = i
             if i < min:
                 min = i
         return (min,max)

4.3 列表生成式

列表生成式即List Comprehensions，用户创建list。range(a,b)可生成a到b-1的list。可与for、if配合使用

>>> l = [x * x for x in range(1, 11)]
>>> l
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> l = [x * x for x in range(1, 11) if x * x %2 ==0]
>>> l
[4, 16, 36, 64, 100]
>>> l = [x + y for x in 'ABC' for y in 'XY']
>>> l
['AX', 'AY', 'BX', 'BY', 'CX', 'CY']

#list中的字符串字母变小写
L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [x.lower() for x in L1  if isinstance(x,str)]

4.4 生成器

如果list元素特别多时，若直接创建list会占用过多空间。若列表元素可根据某种算法推算出来，则可以在循环的过程中推算出后续的元素。Python中，一边循环一边计算的机制，称为生成器：generator。

创建方法一：将list的[]改为()

>>> l = [x * x for x in range(11)]
>>> l
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> g = (x * x for x in range(11))
>>> g
<generator object <genexpr> at 0x0000000000B5B308>

访问元素时，可使用next(g)逐一计算下一个元素，直至没有更多元素时，返回StopIteration错误。也可以使用for n in g访问。

若算法比较复杂，可使用函数实现，并用yield关键字，将函数变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

 #把杨辉三角每一行看做一个list，试写一个generator，不断输出下一行的list：
 def triangles():
     L = [1]
     while True:
         yield L
         L = [1] + [L[i] + L[i + 1] for i in range(len(L)-1)] + [1]

4.5 迭代器

凡是可作用于for循环的对象都是Iterable类型；

可以使用isinstance()判断一个对象是否是Iterable对象：

 >>> from collections import Iterable
 >>> isinstance([],Iterable)
 True
 >>> from collections import Iterator

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

可以使用isinstance()判断一个对象是否是Iterator对象：

 >>> isinstance([],Iterator)
 False
 >>> isinstance((x for x in range(0,10)),Iterator)
 True

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

>>> isinstance(iter([]),Iterator)
True