python学习笔记

一

1.python 变量

将数据放入变量的过程叫赋值。Python 使用等号"="作为赋值运算符，如：

name=value

name 表示变量名；value 表示值。

例如，下面的语句将整数 10 赋值给变量 n：

n=10

从此以后，n 就代表整数 10，使用 n 也就是使用 10。

或

pi=3.1415926

注意，变量的值并不是一成不变的，它随时可被修改，仅需重新赋值即可。变量的值一旦被修改，那么之前的值便会被覆盖，所以一个变量只能容纳一个值

如

1.
	m=2
	print(m)
	2
2.
	m=20
	m=35
	print(m)
	35

2.基本输入输出

2.1 input()输入函数

input()函数： 读入一个字符串
print('Hello,world') #Hello world
s=input() 小明
print('Hello',s) Hello 小明
print(input()) #input()作为print()的参数
注意：读入的字符串不能直接用于数学运算

1.
s=input()	100
print(3*s)	100100100	#字符串重复

2.
a=input() 10
b=input() 50
print(a+b) 1050		#字符串拼接

int()函数 可将整数输入转为可用于数学运算的整形

 #输入矩形边长计算面积
 a=int(input())    	10	#input()作为int()的参数
 b=int(input())		50
 print(a*b)			500		#数学乘法运算
a=input()
b=input()
print(int(a)*int(b))

flaot()函数将浮点数或整数输入转为可浮点类型

2.2 print()输出函数

print(*objects,sep='',end='\n',fiel= sys.stdout,flush=False)

*objects ：输出对象，一个或多个
print('Hello World!') #Hello World!
print(3) #3
print(3+2) #5
ls = [1,2,3,4,5] # [1, 2, 3, 4, 5] 是列表，是一个对象
print(ls) # [1, 2, 3, 4, 5]
print(*ls) # 1 2 3 4 5
print(1,2,3,4,5) # 1 2 3 4 5，多个对象
sep：多个参数输出的分隔字符，默认空格
print('Hello',' World!') # Hello World!
print(3,2,8) # 3 2 8
print(3,2,8 , sep=',') # 3,2,8
print(8,26,18 , sep=':') # 8:26:18
end：输出结束时的字符，默认是换行符 \n
for i in range(4):
print(i)
0
1
2
3

for i in range(4):
print(i,end = ’ ') #0 1 2 3
for i in range(4):
print(i,end = ‘,’) #0,1,2,3,

Python输出：str.format()
<模版字符串>.format(<逗号分隔的参数>)
输出：Tom，男，40
默认按替换域出现的顺序输出

print('{}，{}，{}'.format('Tom', '男', 40))

根据序号到format() 里查找序号对应的值进行填入

print('{2}，{1}，{0}'.format(40,'男','Tom'))

给每一个变量赋值，按替换域的变量名顺序输出

print('{name}，{gender}，{age}' .format(age=40, gender='男', name='Tom'))

模板字符串中说明性字符串将被原样输出

print('姓名：{}，性别：{}，年龄：{} '  .format('Tom', '男', 40))

输出：姓名：Tom，性别：男，年龄：40

3.字符串

字符串是由多个字符组成的集合，由单引号’‘或双引号“”围住字符串以使用。
在python中，单多字符皆认为是字符串，所以在python中单引号’‘与双引号“”并无区别，起到相同作用。
例：

print("Hello，world")
print('Hello, world')

Hello，world
Hello，world

在输出数字时，将数字或数学表达式直接用print表达即可

print(100)
print(15+20)
print(3+8/2-2*2)

100
35
3.0

注意，输出数字时不能够用引号，否则就是字符串：

print('100+20')

结果为100+20,不是120

4.python 运算符

运算符示例	功能说明
x+y	算数加法，列表、元祖、字符串合并
x-y	算术减法，集合差集
x*y	惩罚，序列重复
x/y	真除法，结果为实数
x//y	求整数，向下取整
-x	相反数
x%y	余数，字符串格式化
x**y	幂运算，y可以为实数，例如y取0.5表示平方根
x<y,x<=y,x>y,x>=y	大小比较（可以连用），集合的包含关系比较
x==y,x!=y	相等比较，不等比较
x or y	逻辑或（只有x为假才会计算y），最后计算的子表达式的值作为整个表达式的值
x and y	逻辑与（只有x为真才会计算y）
not x	逻辑非
x in y,x not in y	成员测试运算符
x is y， x is not y	对象同一性测试（测试两个对象引用的地址是否相同）
I、^、&、<<、>>、~	位运算符
&、I、^	集合交集、并集、对称差集

二

2.1 列表对象常用方法

方法	说明
append(x)	将元素x添加至列表尾部
extend(iterable)	将可迭代对象iterable中所有元素添加至列表尾部
insert(index,x)	在列表指定位置index处添加元素x
remove(x)	在列表中删除首次出现的指定元素
pop([index])	删除并返回列表对象指定位置的元素，默认为最后一个元素
clear()	删除列表中所有元素，但保留列表对象
index(x)	返回第一个值为x的元素的下标，若不存在值为x的元素，则抛出异常
count(x)	返回指定元素x在列表中的出现次数
reverse()	对列表元素进行原地翻转
sort(key=None,reverse=False)	对列表元素进行原地排序
copy()	返回列表对象的浅复制

2.2 列表的创建

使用赋值运算符=直接将一个列表赋值给变量即可创建列表对象。
例如：

>>> a_list=['a','b','c','d','e','f']
>>> a_list=[] 			#创建空列表

除使用前面介绍的方括号语法创建列表之外，Python 还提供了一个内置的 list() 函数来创建列表，list() 函数可用于将元组、区间（range）等对象转换为列表。

a_tuple = ('crazyit', 20, -1.2)
# 将元组转换成列表
a_list = list(a_tuple)
print(a_list)

2.3 列表元素的添加

使用+运算符可以将多个序列连接起来；列表是序列的一种，所以也可以使用+进行连接，这样就相当于在第一个列表的末尾添加了另一个列表。
例如：

a_list = ["a", "b", "c"]
b_list = [1, 2, 3]
sum = a_list + b_list

print("a_list =", a_list)
print("b_list =", b_list
print("sum =", sum)

结果为：

a_list = ['a', 'b', 'c']
b_list = [1, 2, 3]
sum = ['a', 'b', 'c', 1, 2, 3]

从上可知，使用+会生成新的列表，而原有列表不会被改变。
+多用于进行列表的拼接，在python中有专门的方法添加元素。

2.3.1 append()方法添加元素

append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：
list.append(obj)
其中，list 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。
例如：

list = ['a', 'b', 'c']
#追加元素
list.append('d')
print(list)

输出结果为：

['a','b','c','d']

2.3.2 extend()方法添加元素

使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至改列表对象尾部。通过extend方法来增加列表元素也不改变其内存首地址，属于原地操作。extend() 和 append() 的不同在于：extend() 不会把列表视为一个整体，而是把它们包含的元素逐个添加到列表中。
extend()的格式如下：list.extend(obj)
其中，list 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。
例如：

>>>a.extend([7,8,9])
>>>a
[5,2,4,7,8,9]
>>>alist.extend([11,13])
>>>alist
[3,4,5,7,9,11,13]
>>>alist.extend((15,17))
>>>alist
[3,4,5,7,9,11,13,15,17]

2.3.3 insert()方法插入元素

append() 和 extend() 方法都只能在列表尾部插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。使用列表对象的insert()方法将元素添加值列表的指定位置，也属于原地操作
insert() 的语法格式如下：list.insert(index , obj)
其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。

当插入列表时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。

>>>alist.insert(3,6)
>>>alist
[3,4,5,6,7,9,11,13,15,17]

提示，insert() 主要用来在列表的中间位置插入元素，如果你仅仅希望在列表的末尾追加元素，那更建议使用 append() 和 extend()。

2.4 列表元素的删除

2.4.1 del：根据索引值删除元素

del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。
del 可以删除列表中的单个元素，格式为：
del list[index]
其中，list 表示列表名称，index 表示元素的索引值。

name = ["a", "b", "c", "d", "e", "f"]
del name[2]
print(name)

结果为：

["a", "b", "c", "d", "e", "f"]

del 也可以删除中间一段连续的元素，格式为：
del list[start : end]
其中，start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。

name = ["a", "b", "c", "d", "e", "f"]
del name[1:4]
print(name)

结果为：

["a","e","f"]

2.4.2 pop()：根据索引值删除元素

pop() 方法用来删除列表中指定索引处的元素，具体格式如下：
list.pop(index)
其中，list 表示列表名称，index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素。
例如：

nums = [40, 36, 89, 2, 36, 100, 7]
nums.pop(3)
print(nums)
nums.pop()
print(nums)

运行结果：

[40, 36, 89, 36, 100, 7]
[40, 36, 89, 36, 100]

2.4.3 remove()：根据元素值进行删除

需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。
例如：

nums = [40, 36, 89, 2, 36, 100, 7]
#第一次删除36
nums.remove(36)
print(nums)
#第二次删除36
nums.remove(36)
print(nums)
#删除78
nums.remove(78)
print(nums)

结果为：

[40, 89, 2, 36, 100, 7]
[40, 89, 2, 100, 7]
Traceback (most recent call last):
    File "C:\Users\z1685\Desktop\homework.py", line 9, in <module>
        nums.remove(78)
ValueError: list.remove(x): x not in list

2.4.4 clear()：删除列表所有元素

clear() 用来删除列表的所有元素，也即清空列表，请看下面的代码：

list=[1,2,3,4,5]
list.clear()
print(list)

结果为：

[]

三

3.1 条件表达式

逻辑运算符and和or以及关系运算符具有惰性求值特点，只计算必须计算的表达式。

以“and”为例，对于表达式“表达式1 and 表达式2”而言，如果“表达式1”的值为“False”或其他等价值时，不论“表达式2”的值是什么，整个表达式的值都是“False”，此时“表达式2”的值无论是什么都不影响整个表达式的值，因此将不会被计算，从而减少不必要的计算和判断。
在设计条件表达式时，如果能够大概预测不同条件失败的概率，并将多个条件根据“and”和“or”运算的短路求值特性来组织先后顺序，可以大幅度提高程序运行效率。

>>> def Join(chList, sep=None):
	    return (sep or ',').join(chList)
>>> chTest = ['1', '2', '3', '4', '5']
>>> Join(chTest)
'1,2,3,4,5'
>>> Join(chTest, ':')
'1:2:3:4:5'
>>> Join(chTest, ' ')
'1 2 3 4 5'

3.1.1 单分支选择结构

if 表达式:
语句块

x = input('Input two number:')
a, b = map(int, x.split())
if a > b:
   a, b = b, a               #序列解包，交换两个变量的值
print(a, b)

3.1.2 双分支结构

if 表达式:
语句块1
else:
语句块2

**>>> chTest = ['1', '2', '3', '4', '5']
>>> if chTest:
	  print(chTest)
else:
	  print('Empty')

['1', '2', '3', '4', '5']
**

Python还支持如下形式的表达式：三元运算符

value1 if condition else value2

当条件表达式condition的值与True等价时，表达式的值为value1，否则表达式的值为value2。在value1和value2中还可以使用复杂表达式，包括函数调用和基本输出语句。这个结构的表达式也具有惰性求值的特点

>>> a = 5
>>> print(6) if a>3 else print(5)
6
>>> print(6 if a>3 else 5)
6
>>> b = 6 if a>13 else 9
>>> b
9

#此时还没有导入math模块
>>> x = math.sqrt(9) if 5>3 else random.randint(1, 100)
NameError: name 'math' is not defined
>>> import math
#此时还没有导入random模块，但由于条件表达式5>3的值为True，所以可以正常运行
>>> x = math.sqrt(9) if 5>3 else random.randint(1,100) 
#此时还没有导入random模块，由于条件表达式2>3的值为False，需要计算第二个表达式的值，因此出错
>>> x = math.sqrt(9) if 2>3 else random.randint(1, 100)
NameError: name 'random' is not defined
>>> import random
>>> x = math.sqrt(9) if 2>3 else random.randint(1, 100)

3.1.3 多分支结构

if 表达式1:
语句块1
elif 表达式2:
语句块2
elif 表达式3:
语句块3
else:
语句块4

其中，关键字elif是else if的缩写。

例3.1 利用多分支选择结构将成绩从百分制变换到等级制

def func(score):
	    if score > 100:
		return 'wrong score.must <= 100.'
	    elif score >= 90:
		return 'A'
    elif score >= 80:
		return 'B'
    elif score >= 70:
		return 'C'
    elif score >= 60:
		return 'D'
    elif score >= 0:
		return 'E'
    else:
		return 'wrong score.must >0'	

3.1.4 选择结构的嵌套

if 表达式1:
    语句块1
    if 表达式2:
        语句块2
    else:
        语句块3
else:
    if 表达式4:
        语句块4

例子 使用嵌套的选择结构实现百分制成绩到等级制的转换。

>>> def func(score):
	    degree = 'DCBAAE'
	    if score > 100 or score < 0:
        return 'wrong score.must between 0 and 100.'
    else:
        index = (score - 60)//10
        if index >= 0:
            return degree[index]
        else:
		     return degree[-1]

3.2 for循环与while循环

Python提供了两种基本的循环结构语句——while和for。
while循环一般用于循环次数难以提前确定的情况，也可以用于循环次数确定的情况。
for循环一般用于循环次数可以提前确定的情况，尤其是用于枚举序列或迭代对象中的元素。
一般优先考虑使用for循环。
相同或不同的循环结构之间都可以互相嵌套，实现更为复杂的逻辑。
for循环和while循环都可以带else。

while 条件表达式:
	循环体
[else:                     # 如果循环是因为break结束的，就不执行else中的代码
	else子句代码块]


for 取值 in 序列或迭代对象:
	循环体
[else:
    else子句代码块]
   

3.3 循环结构的优化

为了优化程序以获得更高的效率和运行速度，在编写循环语句时，应尽量减少循环内部不必要的计算，将与循环变量无关的代码尽可能地提取到循环之外。对于使用多重循环嵌套的情况，应尽量减少内层循环中不必要的计算，尽可能地向外提。
优化前的代码：

digits = (1, 2, 3, 4)

for i in range(1000):
    result = []
    for i in digits:
        for j in digits:
            for k in digits:
                result.append(i*100+j*10+k)

优化后的代码：

for i in range(1000):
    result = []
    for i in digits:
        i = i*100
        for j in digits:
            j = j*10
            for k in digits:
                result.append(i+j+k)

在循环中应尽量引用局部变量，因为局部变量的查询和访问速度比全局变量略块。另外，在使用模块中的方法时，可以通过将其直接导入来减少查询次数和提高运行速度。

import time
import math

start = time.time()                    #获取当前时间
for i in range(10000000):
    math.sin(i)
print('Time Used:', time.time()-start) #输出所用时间

loc_sin = math.sin
start = time.time()
for i in range(10000000):
    loc_sin(i)
print('Time Used:', time.time()-start)

3.4 break和continue语句

break语句在while循环和for循环中都可以使用，一般与选择结构结合使用，一旦break语句被执行，将使得整个循环提前结束。
continue语句的作用是终止当前循环，并忽略continue之后的语句，然后回到循环的顶端，提前进入下一次循环。
除非break语句让代码更简单或更清晰，否则不要轻易使用。

下面的代码用来计算小于100的最大素数，注意break语句和else子句的用法。

>>> for n in range(100, 1, -1):
    for i in range(2, n):
		if n%i == 0:
			break
    else:
		print(n)
		break	

删除上面代码中最后一个break语句，则可以用来输出100以内的所有素数。

>>> for n in range(100, 1, -1):
    for i in range(2, n):
		if n%i == 0:
		    break
    else:
		print(n, end=' ')

97 89 83 79 73 71 67 61 59 53 47 43 41 37 31 29 23 19 17 13 11 7 5 3