Python(一)

---

前言

python语言的基础教程

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、简单的一个python程序

temp = input("不妨猜一下小甲鱼想的哪个数字")
guess = int(temp)

if guess == 8:
    print("yes")
else:
    print("error")
print("game over")

二、python概念

1.变量

变量是python中的一个标签 比如 x = 3
=可以给变量赋值，使用print可以把变量输出
如果想要给两个变量交换值，可以引入一个中间变量，也可以直接交换

x = 3
y = 3
z = x
x = y
y = z
or
x, y = y, z

2.字符串

字符串表示文本序列，使用单引号或者双引号将文本包含起来，不能混用
也可以使用转义字符\，反斜杠

print('I love you')
print("I love you")
print("Let's go")
print('\"Life is short, let\'s learn Python\"')

如果想要使用反斜杠，可以使用\\来表示，这样就会输出反斜杠，比如要输出路径D:\three\two\one\now
在python中就要使用

print("D:\\three\\two\\one\\now")

当然也可以直接使用原始字符串，此时的转义字符不再有效

print(r"D:\three\two\one\now")

原始字符串末尾不能有反斜杠（\ ），\也代表着输入没有完成，\n\之后可以继续输入内容代表着跨行
除此之外，长字符串可以直接代表跨行，不需要使用反斜杠，长字符串用三个单引号或者三个双引号表示，注意前后呼应

poetry = '''
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。
'''

• 字符串的加法和乘法
  字符串的加法就是字符串的拼接，乘法可以多次复制

  print('123'+'456')
  输出 123456
  print('123'*3)
  输出123123123
  
  

可以使用join添加字符或者字符串
.join()的参数要求是可迭代的

a = '我喜欢'
b = '你'
print(''.join(a, b))
输出我喜欢你

可以使用insert插入字符串
insert属于列表的方法, .insert()方法不返回参数，直接对原始字符串进行修改

 a = '我喜欢'
 b = '不'
 str_list = list(a)
 str_list.insert(1,b)
 print(str_list)
 ['我', '不','喜', '欢' ]
 print(''.join(str_list)
 我不喜欢

3.运算符

python常用的运算符有以下

运算符	含义
<	判断左边是否小于右边
<=	判断左边是否小于或等于右边
>	判断左边是否大于右边
>=	判断左边是否大于或等于右边
==	判断左边是否等于右边
!=	判断左边是否不等于右边
is	判断两个对象的id是否相等
is not	判断两个对象的id是否不相等

---

三、数字类型

1.整数

python的整数长度是不受限制的，python的6/3 = 3.0默认结果是浮点数

2.浮点数

python的浮点数不是百分百准确的，python的0.1+0.2 ！= 0.3
想要精确的计算浮点数需要使用decimal模块
E记法，即科学计数法python用5e-05表示0.00005

3.复数

复数有实部和虚部，实部和虚部是用浮点数保存的
x = 1 + 2j
可以用x.real()获得x的实部，用x.imag()获得x的虚部
最后输出1.0和2.0

4.计算操作

操作	结果
x+y	x加y的结果
x-y	x减y的结果
x*y	x乘以y的结果
x/y	x除以y的结果
x//y	x除以y的结果(地板除，结果是整数，不是则向下取整)
x%y	x除以y的余数
-x	x的相反数
+x	x本身
abs(x)	x的绝对值
int(x)	将x转换为整数
float(x)	将x转换为浮点数
complex(re，im)	返回一个复数，re是实部，im是虚部
c.conjugate（）	返回c的共轭复数
divmod(x，y)	返回(x//y,x%y)
pow(x，y)	计算x的y次方
x**y	计算x的y次方

---

四、布尔值

True 和False
定义为False的对象：None和False
值为0的数字类型：0,0.0,0j,Demical(0),Fraction(0,1)(分子为0，分母为1)
空的集合和序列：‘’,(),[],{},set(),range(0)
逻辑运算包含三种 and or not，运算顺序为 not and or

• 短路逻辑：从左往右，只有前一个操作数无法确定结果的时候才继续计算
  3 and 4 输出4
  3 or 4 输出3

---

五、分支与循环

• 分支

第一种
   if（条件）：
       代码
 第二种
   if （条件）：
   	代码
   else：
   	代码
 第三种
  if（条件）：
  		代码
  	elif（条件）：
  		代码
  	elif （条件）：
  		代码
  	else：
  		代码

条件语句，可以把一个分支变成一句话嵌入程序

if a<b:
		small = a
	else:
		small = b
可以写成 small = a if a < b else b

除此之外，分支还可以嵌套

• 循环

while condition:
	statement(s)
for 变量 in 可迭代对象：
	statement(s)
for循环一般和range()一起使用
range(stop),range(10)生成0-9之间的数字
range(start, stop)
range(start, stop, step)
break可以退出循环，直接退出整个循环
continue可以跳出本轮循环，继续下一次循环

---

六、列表

python的列表功能强大，可以存储不同类型的数据
x=[1,2,3,'123'],可以用len(x)获取列表的长度
x[-1]可以获取列表的最后一个元素，x[-2]获取倒数第二个元素

1.列表切片

通过切片可以获取列表中的一部分元素，比如x[1:3]打印[2,3]
x[1:]输出第二个到最后的元素即[2,3,‘123’]
x[:1]输出输出第一个元素[1]
x[:]输出整个数组
列表还可以像range函数一样跳着来x[0:4:2]会输出[1,3]，x[::2]会输出一样的结果，因为0-4包含列表所有元素
如果想要将整个列表倒序输出可以直接用x[::-1]，x[::-2]会倒序跳两个输出结果即[‘123’,2]

2.列表的增删改查

• 增
  append()可以直接在列表的末尾添加元素，每次只能添加一个元素
  extend()允许添加一个可迭代对象，直接添加到列表最后
  insert()方法可以在列表的任意位置添加元素，insert有两个参数，第一个是插入的位置，第二个是插入的元素
  使用切片也可以完成上述功能

  a = [1,2,3,4,5]
  a.append(6)和a[len(a)]=6是一样的结果
  a.extend([6,7,8])和a[len(a):]=[6,7,8]是一样的结果
  b = [1,3,4,5]
  b.insert(1,2)
  print(b)
  输出[1,2,3,4,5]
  

• 删
  remove()函数可以完成对列表元素的删除

  a = [1,2,3,4,5]
  a.remove(4)
  print(a)
  输出[1,2,3,5]
  

  注意

  如果列表中只有存在多个匹配的元素，那么它只会删除第一个
  如果指定的元素不存在，那么就会出错
  ···
  

pop()函数可以根据索引值删除列表的元素

a = [1,2,3,4,5]
a.pop(3)
print(a)
输出[1,2,3,5]

想要直接清空列表可以直接用clear()列表直接变成空列表

• 改
  列表是可变的，字符串是不可变的
  要对列表元素进行替换，可以直接用索引，多个列表元素可以用切片

   a = [1,2,9,4,5]
   a[2] = 3
   a变为[1,2,3,4,5]
   a[3:]=[14,15,16,17]
   a变为[1,2,3,14,15,16,17]
  

python提供sort()函数可以对列表进行排序，默认从大到小，如果加入参数reverse=True就会从小到大
reverse()可以反转列表的元素

>>> a = [4,7,2,6,9]
>>> a.reverse()
>>> print(a)
[9, 6, 2, 7, 4]
>>> a.sort()
>>> print(a)
[2, 4, 6, 7, 9]
>>> a = [4,7,2,6,9]
>>> a.sort(reverse=True)
>>> print(a)
[9, 7, 6, 4, 2]

• 查
  count()可以对列表中的元素进行计数
  index()可以查找列表中元素的索引值(第一个找到的位置)，可以指定查找范围
  copy()可以拷贝列表

>>> a = [4,7,2,6,9,2,2]
>>> a.count(2)
3
>>> a.index(9)
4
>>> a.index(2,3,6)
5
以下都是浅拷贝
>>> a_copy = a.copy()
>>> print(a_copy)
[4, 7, 2, 6, 9, 2, 2]```
也可以使用切片的方法
a_copy = a[:]

3.列表的加法和乘法

>>> s = [1,2,3]
>>> t = [4,5,6]
>>> s+t
[1, 2, 3, 4, 5, 6]
>>> s*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

4.嵌套列表

python允许列表中嵌入新的列表
访问嵌套列表用循环语句，也可以用下标

>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> for i in matrix:
	for e in i:
		print(e,end=' ')
	print()

	
1 2 3 
4 5 6 
7 8 9 
>>> matrix[0]
[1, 2, 3]
>>> matrix[0][1]

也可以用循环生成嵌套列表，注意下面A和B的不同

>>> A = [0]*3
>>> A
[0, 0, 0]
>>> for i in range(3):
	A[i] = [0]*3
>>> A
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> B = [[0]*3]*3
>>> B
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> A[1][1]=1
>>> A
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
>>> B[1][1]=1
>>> B
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]

小知识
is运算符
python对于不同的数据类型存储方式也不尽相同，由于字符串是不可变类型，所以只需要在内存中开辟一个位置来存放。但是列表是可变的，python会开放两个不同的内存存放列表

>>> x = "Fish"
>>> y = "Fish"
>>> x is y
True
>>> x = [1,2,3]
>>> y = [1,2,3]
>>> x is y
False

5.深拷贝和浅拷贝

python的赋值只是将一个变量的引用传递给另一个变量
想要得到两个独立的列表就需要用拷贝

>>> x = [1,2,3]
>>> y=x
>>> x[1]=1
>>> x
[1, 1, 3]
>>> y
[1, 1, 3]
>>> x = [1,2,3]
>>> y =x.copy()
>>> x[1]=1
>>> x
[1, 1, 3]
>>> y
[1, 2, 3]
>>> x = [1,2,3]
>>> y = x[:]
>>> x[1]=1
>>> x
[1, 1, 3]
x
>>> y
[1, 2, 3]

但是对于嵌套列表上述方法就会失灵，浅拷贝只拷贝外层对象，对于内部对象只是引用
所以需要深拷贝，深拷贝需要引入copy模块，而且效率比较低

>>> import copy
>>> x = [[1,2,3],[4,5,6],[7,8,9]]
>>> y =copy.copy(x)
>>> x[1][1]=0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> x = [[1,2,3],[4,5,6],[7,8,9]]
>>> y = copy.deepcopy(x)
>>> x[1][1]=0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> 

6.列表推导式

基本语法：[expression for target initerable]
给列表中的每个值乘以2

>>> a = [1,2,3]
>>> a = [i*2 for i in a]
>>> a
[2, 4, 6]
ord()返回字符的ASCII数值或者Unicode数值
>>> y = [c*2 for c in "Fishc"]
>>> y
['FF', 'ii', 'ss', 'hh', 'cc']
>>> code = [ord(c) for c in "Fishc"]
>>> code
[70, 105, 115, 104, 99]

列表推导式可以对多维列表进行创建、操作

>>> s = [[0]*3 for i in range(3)]
>>> s[0][0]=1
>>> s
[[1, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> x = [[1,2,3],[4,5,6],[7,8,9]]
>>> y = [row[1] for row in x]
>>> y
[2, 5, 8]

列表推导式还可以加入用于筛选的if语句
[expression for target in iterable if condition]
顺序是先执行for语句然后执行if语句然后执行最后的表达式语句

>>> a = [ i for i in range(10) if i%2 == 0]
>>> a
[0, 2, 4, 6, 8]
>>> a = [ i+1 for i in range(10) if i%2 == 0]
>>> a
[1, 3, 5, 7, 9]
筛选出f开头的单词
>>> words = ["great", "fishc","brilliant","excellent","fantistic"]
>>> a = [x for x in words if x[0]=='f']
>>> a
['fishc', 'fantistic']

列表推导式可以是嵌套的
嵌套的列表推导式对应嵌套的循环
[expression for target1 in iterable1 for target2 initerable2 ··· for targetN initerableN]

>>> x = [[1,2,3],[4,5,6],[7,8,9]]
>>> flatten = [col for row in x for col in row]
>>> flatten
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> [x + y for x in "dog" for y in "DOG"]
['dD', 'dO', 'dG', 'oD', 'oO', 'oG', 'gD', 'gO', 'gG']

列表推导式的每个for循环都可以追加一个if进行判断
以下两种表示等价

>>> [[x,y] for x in range(10) if x %2 ==0 for y in range(10) if y%3==0]
[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]
>>> _ = []
>>> for x in range(10):
	if x%2==0:
		for y in range(10):
			if y%3==0:
				_.append([x,y])			
>>> _
[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]

列表推导式可以写的很复杂庞大，虽然他效率高，比较简洁，但是可读性比较差，后期维护不太容易，要根据情况选择合适的代码

---

七、元组

元组是不可变的，支持切片操作，不可以修改元素，支持count和index两种方法
元组可以加法和乘法，也可以嵌套。

>>> rhyme = (1,2,3,4,5,"上山打老虎")
>>> rhyme
(1, 2, 3, 4, 5, '上山打老虎')
>>> rhyme = 1,2,3,4,5,"上山打老虎"
>>> rhyme
(1, 2, 3, 4, 5, '上山打老虎')
>>> rhyme[-1]
'上山打老虎'
>>> nums = [1,3,6,4,3,3]
>>> nums.count(3)
3
>>> nums.index(6)
2
>>> s = (1,2,3)
>>> t = (4,5,6)
>>> s+t
(1, 2, 3, 4, 5, 6)
>>> s*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> w=s,t
>>> w
((1, 2, 3), (4, 5, 6))

元组支持迭代，列表推导式

>>> s = (1,2,3)
>>> for k in s:
	print(k)

	
1
2
3
>>> [each*2 for each in s]
[2, 4, 6]
生成只有一个元素的元组，必须加这个逗号
>>> a = (2,)
>>> type(a)
<class 'tuple'
元组的解包
>>> a,b,c = s
>>> a
1
>>> b
2
>>> c
3

---

python的一些模块

1.random

可以获取伪随机数

import random
random.randint(1,100)

上面的代码可以获取从1-100之间的一个随机数
random生成的随机数是可以被重现的，默认情况下，使用当前操作系统的时间作为种子

x = random.getstate()
print（random.randint(1,100)）
print（random.randint(1,100)）
print（random.randint(1,100)）
x保存当前random的种子，将random的种子重置为之前的x，就可以生成和之前一模一样的数字了，上面输出的三行和下面输出的三行会输出一样的数字
random.setstate(x)
print（random.randint(1,100)）
print（random.randint(1,100)）
print（random.randint(1,100)）

2.decimal

decimal模块可以精确的计算浮点数

import decimal
a = decimal.Decimal('0.1')
b = decimal.Decimal('0.2')
print(a+b)
结果会输出0.3