Python入门（一）

2022-02-20 15:20:46

本文是个人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

码农公寓

一 安装

二 语法基础