一
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