Python基础学习看这个就够了(未完结）

Python学习笔记

用Python实现伪随机数重现

>>>import random                //Python需要引入模块函数
>>> x = random.getstate()
>>> random.setstate(x)       //在此之前先生成一部分随机数(省)
>>> random.randint(1,10)
8
>>> random.randint(1,10)
9
>>> random.randint(1,10)
6
>>> random.randint(1,10)
8
>>> random.randint(1,10)
1
>>> random.randint(1,10)
10

世界上本没有随机数，这些随机数只是跟操作系统时间有关的种子，只有当量子计算机出现的时候，才能产生真正的随机数

博主本人有一定的C语言基础，所以笔记中没有太基础的内容，只是附上代码，以便日后浏览复习~~

---

数据类型

Python 与 C语言浮点数存储类似，浮点数比较和运算都会有精度的限制，产生一些误差，如下：

>>> 0.1 + 0.3
0.4
>>> 0.1+0.2
0.30000000000000004
>>> 0.1 + 0.1
0.2
>>> 

在一些行业中对精度要求很高，所以引入十进制模块的应用：

decimal

import decimal
a = decimal.Decimal('0.1')
b = decimal.Decimal('0.2')
print(a + b)      

>>0.3    
--------------------------------------------------      
c = decimal.Decimal('0.1')    //*比较也需要同类型*
a + b == c
>>True

复数

>>> 1+3j
(1+3j)
>>> a = 1 + 3j       //a.real获取复数的实部
>>> a.real 			//a.imag获取复数的虚部  (float)
1.0
>>> a.imag
3.0

运算

1.// 地板除   意思是向下取整 例如 3//2 = 1  -3//2 = -2.与C不同，3/2 = 1.5
2. % 取余同C语言中的取余
3. divmod Python内置函数无需import  用法是 divmod(x,y) 表示 求出 x // y , x % y 的结果。
4. x与-x 即相反数 Python中加负号可代表相反数
5. abs()； 实数领域表绝对值 复数领域表取模
6. int() 同C
7. float(); complex();等等都可以将括号里的参数转换成相应的的数据类型 里面可以填入字符串进行转换
8. pow();  见代码

>>> divmod(3,2)
(1, 1)               //前面参数除以后面参数
>>> abs(-3)
3
>>> abs(2)			//绝对值
2
>>> abs(1+2j)       //取模
2.23606797749979
>>> int(9.99)
9
>>> int(5.2)
5
/*---------------------------*/
>>> complex('1+2j')            //注意 字符串中加空格会报错
(1+2j)
>>> float(290)
290.0
/*----------------------------*/
>>> pow(2,3)         		 //2^3 = 8
8
>>> 2**3                   	//功能与pow(2,3)相同
8
>>> pow(2,-3)				
0.125
>>> pow(2,3,5)				//与下面相似
3
>>> 2 ** 3 % 5
3

布尔类型

布尔类型只有两种类型，真or假。
*示例：*

>>> bool(True)
True
>>> bool('True')
True
>>> bool(23)
True
>>> bool(0)
False
>>> bool(0.0)
False

布尔类型实际就是特殊的整数类型，代表0和1~

逻辑运算符

and、or 和 not
![三种逻辑运算符的说明](https://img-blog.csdnimg.cn/4bce4d014158441497413957c4a2de5b.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5Lik6aKX5rOh6IW-54mH,size_11,color_FFFFFF,t_70,g_se,x_16#pic_center)


这里引出短路逻辑：从左往右，只有当地一个操作数的值无法确定逻辑运算结果的时候，才对第二个操作数进行求值。
这里与计算机默认顺序结构执行有关例如：

• 3 or 4

• 3

• 3 and 4

• 4

  or运算符无需确定后面的数值是几，而and运算符则构成的式子的结果与后面数值有关，所以会产生这种结果。
  另外运算符的优先级可记可不记，考试的话还是记一记叭~，如果只是想学学Python来做一些东西其实没必要记。

  分支结构

  由一个简单的例子来体会一下Python与C中分支语句的不同。

if i < 8:
print("True")
elif 8 < i < 10:
print("not bad")
else:
print("Fulse")

还有一种条件表达式的形式，可以缩减代码行数

print("True")if i < 8 else print("Fulse")

在Python中else语句也能起到检验循环跳出的作用，当循环条件不为真的时候执行else的内容

i = 1
while i < 5:
    print("你坚持了: 天",i)
    i+=1
else:
    print("失败")
============ RESTART: C:/Users/Administrator/Desktop/Python/look.py ============
你坚持了: 天 1
你坚持了: 天 2
你坚持了: 天 3
你坚持了: 天 4
失败

使用Python循环嵌套实现9*9乘法表。

i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(j,"*",i,"=",j*i,end=" ")
        j += 1
    print()
    i += 1
============ RESTART: C:/Users/Administrator/Desktop/Python/look.py ============
1 * 1 = 1 
1 * 2 = 2 2 * 2 = 4 
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9 
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16 
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25 
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36 
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49 
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64 
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81 

for…in

for 变量 in 迭代对象 :
	statement(S)

这里我们创建一个列表说明

temp = ["I","love","you","three","thousands","times"]
for i in temp:
    print(i)
======================= RESTART: C:/Users/Administrator/Desktop/Python/look.py ======================
I
love
you
three
thousands
times

range()

range()函数是for循环的好伙伴，当我们计算一个例如1~100000累加累乘的运算，如果直接写 for i in 100000 是不对的，因为100000是个int类型的整数，不能作为迭代对象。

有三种方式
1.	range(stop)
2.	range(start,stop)
3.	range(start,stop,step)

下面我们进行1-100000累加的程序编写

i = 1
sum = 0
for i in range(100001):
    sum += i
    i += 1
print(sum)

5000050000

列表

列表是可以容纳不同类型数据的

>>> [1,2,3,4,5,"上山打老虎"]
	[1, 2, 3, 4, 5, '上山打老虎']

列表的访问方式也可以像数组一样

temp = [1,2,3,4,5]
temp[0] == 1
temp[3] == 4

当列表的长度非常长，想要访问最后一位时可以这么表示

temp[-1]

表示访问temp列表倒数第一个元素

列表切片

temp[0:3]

表示列表中第一位到第三位的元素，类似于matlab里的向量表

temp[:] 		//表示取出整个列表
temp[:3]  		//表示取出第三位之前的元素
temp[3:]		//表示取出第三位之后的元素
temp[0:5:2]  	//表示跨度为2，从第一位开始，第5位结束
temp[::-2]		//表示倒叙列表跨度为2

append()

temp = [1,2,3,4,5]
temp.append("Go!")
print(temp)

[1, 2, 3, 4, 5, 'Go!']

extend()
这个函数不同于上个，append只能插入一个元素，extend()可以插入一个迭代对象来插入多个内容

extend([1,2,3,4,5])

insert()

s.insert(index,a)			//对列表s进行操作
s.insert(len(s),a)

remove()

s.remove("1")    			//删除列表中的‘1’，如果有多个元素匹配删除下标较小的那个

pop()

s.pop(2)  						//删除列表s中下标为2的内容

clear()

s.clear()						//清空s列表

同样类似于数组操作

s = [1,2,3,4,5]
d = [1,2,3,4,5]
name = ["张三","李四","杨过"]
d[3:] = [11]
s[2] = 100						//2代表index
name[2] = 'ironman'				
print(s)
print(name)
print(d)

-------------answer-----------------
[1,2,100,4,5]
[1,2,11,11,11]
["张三",'ironman',"杨过"]

sort()

s.sort()             //将列表s中的元素升序排列

reverse()

s.reverse()			//将列表s中的元素翻转

s = [3,7,31,5,2,66]
s.sort()
s.reverse()

s = [3,7,31,5,2,66]
s.sort(reverse = True)

上面两种结果相同，都是把s列表中的内容倒序

count()

nums.count(3)					//表示列表s中共有几个3

index()

nums = [1,2,3,4,5,4,3,2,1]
nums.index(3)
2
nums.index(3,0,4)
2
nums.index(3,0,7)
2
nums.index(3,4,7)     //insert(num,start,end)
6

```python
import cv2
print(1,2,3)
# 字符串拼接
print('大赛'+'哈哈'+'哦哦')
name = '看看'
str_college = '理论'
print(name + str_college)
print('1''2')
#type 可以查看数据类型 也可以查看变量存储内容的数据类型
type('123')  #直接查看类型
name_str = '123'
type(name_str)  #查看变量中存储的数据类型 不是查看变量类型
                #py中变量无类型 但是存储的数据有类型
#运算符
# //整除
print("8//2 = ", 8//2)
print("11//2 = ", 11//2)
# %取余
print("11%2 = ", 11%2)
# **求平方
print("2**2 = ", 2**2)
# += -= /= **= //= 同C语言
# 赋值运算符有 1.标准赋值 = 2.复合赋值+=。。。
# ########################################
# 字符串格式化 1.多字符串变量拼接 2.字符串与数字或其他类型拼接
# 1.占位型拼接 %s %d %f
name = 123
message = "说个数 %s" % name     # % 表占位 s 表将变量变成字符串放入占位的地方
print(message)
print(type(message), type(name))  # 将整数转换为字符串插入占位的地方

class_num = 57
final_num = 56
message = "班里一共 %s 个人，就业一共 %s 个人" % (class_num, final_num)
print(message)
# 括号里的顺序为占位的顺序
start_year = 2023
pay_num = 9.9
message = "起始年份为 %d , 花费 %f 元" % (start_year, pay_num)
print(message)
# 可以拼接整数和浮点数
# 格式化过程中数字精度控制  m 控制宽度 宽度小于数字自身不生效 .n 控制小数点精度，小数的四舍五入
# 如数字11 输出格式为%5d  输出 [][][]11 在数据前补充宽度
# %5.2f 表示将宽度控制为5，小数点精度设置为2   计算宽度时小数点也算一位
# f“...{变量}”的格式来快速格式化
print(f"起始年份为{start_year}，花费{pay_num}元")
# 可以直接将表达式写在字符串格式化的括号中
print("起始年份为 %d , 花费 %f 元" % (2020+3, 10-0.1))
print(f"起始年份为{2020+3}，花费{10-0.1}元")
print("字符串在Python中的类型是：%s" % type('字符串')) # 字符串格式化显示表达式结果
# #############################################
# input   输入的都是字符串
print("who are you?")
name = input("clue sentence")
print("我知道了，你是：%s" % name)
################################################
user_name = input("输入用户名")
user_type = input("输入用户类型")
print(f"您好，{user_name},您是尊贵的：{user_type}.欢迎光临")
################################################
# 逻辑判断
# 1.布尔类型 真和假 1和0 True和False
# 2.if 条件:
#  (四个空格缩进归属if）---
age = 10
if age >= 18:
    print("adult")
print("test")
# example
print("welcome to zoo,adult charge ,children free")
age = int(input("please input your age:"))
if age >= 18:
    print("you are adult,please cast 10 $")
print("you are welcome!!")
# if clue:
#     1
# else:
#     1

## if clue:
#     1
#  elif clue2:
#     2
#  else:
#     3
# is 用于判断两个变量是否指向同一对象
a = 123
b = 123
c = 111
print(a is b)
print(a is c)
# help  执行选中内容 alt+shift+E
help(print)
a,b = 1,2 # 系列解包赋值
   # q111
print(a)
# ; 用来一行写多个语句
a = 1;b = 2; c = 4;
# 函数和模块 def
def sayhello(x):
    print("say hello %d times" % (x))
sayhello(3)
# example
import math
def getValue(b,r,n):
    v = b*(1 + r)**n
    return v
total = getValue(1000,0.05,5)
print(total)
#1. module.function(arguments)
import math
a = math.sin(2)
print(a)
#2. from ...
from math import sin
b = sin(1)
print(b)
# class 创建类对象
class Person:
    def saybye(a):
        print("bye!")
p = Person()
p.saybye()
# if 的嵌套
grade = int(input("input grade:"))
if (grade >= 0):
    if (grade > 0):
        y = 1; print(y)
    else:
        y = 0
        print(y)
else:
    y = -1; print(y)

# 在Python3中，range函数的返回值类型不再是列表，而是一个range类型。使用者可以使用list函数继续再将其转化成列表。
for i in range(1,11):
    print(i,end=' ')
#
print(type(range))  # range python3中range类型为类
# 利用for循环求 1~100中所有奇数的和以及偶数的和
sum_ji = 0; sum_ou = 0
for i in range(1,101,1):
    if i % 2 == 1:
        sum_ji += i
    else:
        sum_ou += i
print("奇数和为：",sum_ji)
print("偶数和为：",sum_ou)

# while 循环 求：
sum_all = 0; sum_ji = 0; sum_ou = 0; i = 1
while(i < 101):
    sum_all += i
    i += 1
print("全部的和：",sum_all)
# for or while 循环结束后可接else：
hobbies = ''
for i in range(1,4):
    s = input("请输入爱好之一（最多三个，按Q或q结束）：")
    if s.upper() == ('Q' or 'q'):
#    if s.upper() == 'Q':
        break
    hobbies += s + ' '
else:
    print('您输入了三个爱好。')
print('您的爱好为：',hobbies)
# 可变序列和不可变序列：1.列表（list）和字节（bytearray）2.字符串（str）元组（tuple）和 字节序列（bytes）
# 返回i的二进制字符串和二进制位数
i = -10
bin(i)
i.bit_length()

h = 'blue' 'sky'
print(h)
# 字符串对象s的方法
s = 'happy'
s.upper()
# str类方法
s = 'happy'
str.upper(s)
# 系列：1.元组 不可变值表（定值表） 2.列表 可变值表 3.字符串