python知识点

一、DOS命令

控制台命令->命令提示符-> cmd -> DOS
不是及时生效.需要重新加载|

1、路径

当前路径:尚学堂。
绝对路径:地球 中国 甘肃 兰州 新区 图书馆
相对路径:参照当前路径。

2、常用命令

1）.盘符：C: D：E：
2）.当前盘符生效：cd：
cd ..进入上一层路径。
cd /进入根路径。
复制，粘贴->鼠标右键。
进入目标路径:。
a.	先路径,后盘符。
b.	先盘符，后路径。
3）常用命令。
dir:打印当前文件目录下的所有文件。
Cls：清除当前屏幕
mkdir:创建文件夹。
exit :退出cmd

二、GVIM 命令

1、三种模式

1）、命令模式(默认模式)。
命令模式:进入文件默认是命令模式。
2）、编辑模式i(insert) a(append).
编辑模式:i当前光标初插入，a光标下一个开始追加。
3）、底行模式->’:’
底行模式:对文件进行检索,保存.退出等等。
三种模式之间的切换:

2、使用:、

文件不存在，创建;文件存在，打开.
a. gvim文件名.后级(创建)。
b. gvim 文件+tab(读取)。
3.编辑
a.进入文件默认就是命令模式。
b.关闭输入法。
c. a或i主进入编辑模式。
d.编辑内容。
e.按esc进入命令模式。
f.按 : 进入底行模式。
wg ->保存并退出。
w->保存。
q ->退出。
q! ->强制退出。

3、其他命令：

3.1、 插入

i a ->光标前后插入。
I A->行首行末插入。
O o->上一行下一行插入。
^(6) $(4) ->行首行尾(移动)。

3.2、删除.

X x ->删除光标前后字符
dd ->删除光标所在行。
数字+dd ->删除当前光标以及后面的对应行数.

3.3、撤销~

u ->回退。

4.4、复制:一行

yy ->复制光标所在行。
数字+yy ->复制当前光标以及后面的对应行数.

3.5、粘贴。

p ->自动换行。

3.6、显示行号。

:set nu ->显示(底行模式)。
:set nonu ->隐藏。

3.7、重复上次操作。

. ->任何上-次操作。

3.8、检索。

:+行号(底行模式)。
/+字符(命令模式)。

3.9其他vim命令：

： s/old/new: 在光标所在一行内，替换第一次出现的字符串。
：s/old/new/g:在光标所在一-行内, 替换所有出现的字符串。
：#, #s/old/new/g:在指定两行内，替换所有出现的字符串。
：%s/old/new/g:替换文档内所有出现的字符串。
：%s/old/new/gc: 用户确认替换文档内所有出现的字符串。

4、使用循环解析器。

使用量广泛的: CPython IPython

三、注释：

注释->给人看，程序员+
主要作用:
a.伪代码
b.帮助理解程序
两种格式:

1、#

单行注释：

 # 以后的代码全部不加载

#以后的代码全部不加载

2、多行注释

'''
多行注释
'''
"""
多行注释

"""

3、程序编程规范

1、合理注释.
2、正确缩进:tab.
3、成对编程.
{代码}  {代码}  {代码}

四、标识符

一、理解标识符.

1、作用:命名，助记符号.

2、命名规格

2.1、组成部分：字母+数字或_数字或字母。
name+
test。
a
box_min
错误：
123abc ->以数字开头。
abc%def -> 有特殊符号。
尚学堂。
因为中文也是字符。

3、命名规范

见名知意、不要中文，尽量使用e文。

五、变量.

可以把变量看成一个盒子。这个盒子是一个万能的盒子，可以装各种东西(数据)，盒子的名字就是变量名，盒子的内容就是变量的数据。
我们通过变量来操纵存储空间中的数据，变量就是指代这个存储空间!空间位置是确定的，但是里面放置什么值不确定!。

一、理解变量.

一切皆变量，变量没有类型。
变量声明后需要马上赋值，否则不可用。
不可以用没有声明的变量。

二、赋值.

值的拷贝

注：正规写法

将b的一份拷贝赋值给a
注：非正规写法

.1、声明格式:。
变量=值+
变量1,变量2,变量3=值1,值2,值予
2、变量的使用。

E.g:1

输出：

# 测试输出
box = '很热'
temp = 30 # 单位度°
book_prick = 55.50 #单位RNB


'''
    1、单个值输出
'''

print(box)
print(temp)
print(book_prick)
print("--------------------------------------")


'''
    2、格式（"字符串%s”%变量）
    %s ->字符串
    %d ->整数
    %f->浮点数（小数）
    务必匹配类型
'''

print(box)
print("天气：%s"%box)
print(temp)
print("温度：%d"%temp)
print(book_prick)
print("书的价格：%f人民币"%book_prick)
print("书的价格：%.2f人民币"%book_prick)
print("------------------------------------")


'''
    3、多个值
    print(变量1，变量2，变量3)
    print("%s %d %f"%(变量，变量，变量))
    %s ->字符串
    %d ->整数
    %f->浮点数（小数）
    务必匹配类型
'''

print(box, temp, book_prick)
print("信息：",box, temp, book_prick)
# 语法没有报错，但输出的不是我们要的格式
# print("天气：%s, 温度：%d度,书的价格：%.2f人民币", box, temp, book_price)
print("天气：%s, 温度：%d度,书的价格：%.2f人民币"%(box, temp, book_prick))
print("天气：{},  温度：{}度,书的价格：{} 人民币".format(box, temp,book_prick))
print("----------------------------------------")


'''
    4、更改结束符
    end=", "为不换行
'''


print("天气： ", box, end=", ")
print(temp, end=", ")
print(book_prick)

E.g:2
输入：

# 测试输入 模拟和用户交互
# input()  按Enter键结束

# 测试1
tel = input("请输入你的电话")
print(tel)
print(len(tel))
print("输入的电话为：{},长度为：{}".format(tel,len(tel)))
print("-"*50)

# 测试2
salary = input("请输入你的月薪：")
print(salary)
sal = int(salary)
# 输入（input）的都是字符串，需要转换
# print("你的月薪为：%d"%salary)
print("你的月薪为： %d"%sal)
print("-"*50)

练习

点名系统

import random
# 点名系统
# 生成[1-5]的随机整数
rand = random.randint(1,5)
# print("生成的随机数为： %d"%rand)
print("生成的随机数为：%d"%rand,end=",对应的用户是：")


# 模拟五个用户
'''
    后期随着数据的增多，目前的这种方式操作不满足我们的需求
    name1 = '1'
    name2 = '2'
    name3 = '3'
    name4 = '4'
    name5 = '5'
    name6 = '6'
'''


# 列表
names = ['王1','王2','王3','王4','王5','王6']
print(names[rand-1])

随机数

import random # 放在首行
# 测试随机整数
# random.randint(min,max)
# (min,max)最小范围和最大范围


#----------------------随机生成[0-100]的数--------begin----------#
rand = random.randint(0,100)
print("生成的随机数为：{}".format(rand))
#----------------------随机生成[0-100]的数--------end------------#

六、基本数据类型

(一)、数据类型

1、数值型: int float boolean

格式：

2、字符串:单个字符、多个字符

格式：

3、列表:有序、可重复、可变的

格式：

4、元组:有序、可重复、不可变

格式：

5、集合:无序、不重复

格式：

6、字典: key键(唯一的、不可重复)-value值

格式：

(二)、数据类型转换

1.数值型

# 数值型
num = 5
# 内置函数
# 将一个十进制整数转换为其他进制数
num = bin(5)
# 将一个十进制整数转换为二进制数
num = oct(5)
# 将一个十进制整数转换为八进制数
num = hex(5)
# 将一个十进制整数转换为二进制数
print('-'*50)
# 将其它进制数转换为十进制数
#int("进制数转换字符串"，进制)
num = int('0b101', 2)
num = int('0o5', 8)
num = int('0x5', 16)
print('-'*50)

2.浮点数

# 浮点数 四舍五入的概念
number = 1234563.789
print(number)
print('小数为：%f'%number)
print('小数为：%0.2f'%number)
print('{0:.2f}'.format(num,number))
print('-'*50)

3.布尔

# 布尔
# True -> 1 False -> 0

4、字符串

4.1.格式

# int('数字格式字符串')
num = int('5')
print('-'*50)

4.2、unicode编码

set(s)	转换为可变集合。
dict(d)	创建一个字典。d必须是一个序列(key,value)元组。
frozenset(s)	转换为不可变集合。
chr(x)	将一个整数转换为-一个字符。
ord(x)	将一个字符转换为它的整数值。
hex(x)	将一个整数转换为一个十六进制字符串。
oct(x)	将一个整数转换为一个八进制字符串。

4.3、编码与解码.

encode(默认utf-8) ->编码->字符列表到字节列表。
decode(默认utf-8) -> 解码->字节列表到字符列表。


防止报错可以‘字节码‘.decode(‘utf_8’, errors = ‘ignore’)

完整版的加密与解密

注意: encode(“ascii”)编码对中文无效

编码一个字符对应一个字节，汉字比较特殊，一个汉字对应三个字节

代码：

# 数值型
num = 5
# 内置函数
# 将一个十进制整数转换为其他进制数
num = bin(5)
# 将一个十进制整数转换为二进制数
num = oct(5)
# 将一个十进制整数转换为八进制数
num = hex(5)
# 将一个十进制整数转换为二进制数
print('-'*50)


# 将其它进制数转换为十进制数
#int("进制数转换字符串"，进制)
num = int('0b101', 2)
num = int('0o5', 8)
num = int('0x5', 16)
print('-'*50)


# int(具体的进制数)  可以省略进制格式，进制不能是字符串
num = int('0b101')
num = int('0o5')
num = int('0x5')
print('-'*50)


# int('数字格式字符串')
num = int('5')
print('-'*50)


# 浮点数 四舍五入的概念
number = 1234563.789
print(number)
print('小数为：%f'%number)
print('小数为：%0.2f'%number)
print('{0:.2f}'.format(num,number))
print('-'*50)


# 布尔
# True -> 1 False -> 0

(三)、运算符

1.运算符

运算符	符号
算数运算符	+ - * / // % **
赋值运算符	=
复合运算符	+= -= *= /= %= **= //=
比较运算符	== != > < >= <=
逻辑运算符	and not or
位运算符	& ^ ~ << >> I
身份运算符	is is not
成员运算符	in not in

2.优先级

符号	运算符
**	指数（最高优先级）
~ + -	按位翻转，一元、加号和减号
*/ % //	乘、除、取整和取整除
±	加法减法
<< >>	左移、右移运算符
&	位”AND“
^ I	位运算符
<= < > >=	比较运算符
< > == !==	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

注意：
关于运算符的优先级，不要刻意的记忆，表达式里面优先级可以使用小括号来组织。

算数运算

1.+：加法、重复

n1 = 2
n2 = 5
print('-'*40)

# + :加法、连接符
print(n1+n2)
print('a'+'b')
print('-'*40)

运行结果如图：

2.-：减法、负数

n1 = 2
n2 = 5
print('-'*40)

# -：减法、负数
print(n2-n1)
print('-'*40)

运行结果如图：

3.*：乘法、重复

n1 = 2
n2 = 5
print('-'*40)

# *：乘法、重复
print(n1*n2)
print('-'*40)

运行结果如图：

4./ :除法

n1 = 2
n2 = 5
print('-'*40)

print(n2/n1)  #可能带有小数
print(n2//n1)  #整除
print('-'*40)

运行结果如图：

5.% ：取余

n1 = 2
n2 = 5
print('-'*40)

print(n2%n1)
print('-'*40)

运行结果如图：

6.**：幂运算

n1 = 2
n2 = 5
print('-'*40)

# **：幂运算
print(n1**n2)
print('-'*40)

运行结果如图：

复合运算

1.+=（加等：a+b=…）
2. -=（减等：a- b=…）
3. *=（乘等：a *b=…)
4. /=（除等：a / b=…）
5. %=（模等：a%b=.）
6. **=（幂等：a ** b=.）
7.//=（整除等：a//b=.）
8.=（赋值）

#赋值
a=2
b=a   #值的拷贝
print('--'*40)


#复合
a +=2
a -=2
a *=2
a /=2
a //=2
a %=2
a **=2
print(a)
print('--'*40)

运行结果演示图：

比较运算

1.==（等于）
2. != （不等于）
3. > （大于）
4. < （小于）
5. >= （大于等于）
6. <=（小于等于）

#比较运算符
a = 10
b = 3
print("---"*10)
#比较运算符只返回布尔值（ture或False）

print(a > b)
print(a < b)
print(a <= b)
print(a <= b)
print(a == b)
print(a !=b)
print("---"*10)

运行图图如下：

逻辑运算

1.and（与运算）
2.or（或运算）
3.not（取反）
注：会有一点不同

1.and

#逻辑运算符 ——>短路问题

a = 10
b = 2
print("---"*10)

'''
    and
    可能取得值
    T - T -> T
    T - F -> F
    F - T -> F
    F - F -> F
    规律1：第一个为flase，结果直接是Flase，为了提高性能，后半部分不参与运算
    规律2：前面是ture，后面也为ture，整个为ture
    总规律：TT为ture，其他都为flase
'''
print("---"*10)
print(a >b and b< 1)
print("---"*10)
print(a > b and int(input("你想输入的数字："))<20) #测试短路；

运行图如下：

2.or

#逻辑运算符 ——>短路问题

a = 10
b = 2
print("---"*10)

'''
    or
     and
    可能取得值
    T - T -> T
    T - F -> T
    F - T -> T
    F - F -> F
    规律1：有一个为Ture，结果直接是Ture，为了提高性能，后半部分不参与运算
    规律2：前面是false，参与运算，后面也为false，整个为false
    总规律：FF为flase，其他都为ture
'''
print("---"*10)
print(a >b or b< 1)
print("---"*10)
print(a > b and int(input("你想输入的数字："))<20) #测试短路；

运行图如下：

3.not

#逻辑运算符 ——>短路问题

a = 10
b = 2
print("---"*10)

'''
    not取反
    flase返回ture
    ture返回flase
'''
print(not(a<b))
print("---"*10)

运行图如下：

逻辑运算的总代码：

#逻辑运算符 ——>短路问题

a = 10
b = 2
print("---"*10)

'''
    and
    可能取得值
    T - T -> T
    T - F -> F
    F - T -> F
    F - F -> F
    规律1：第一个为flase，结果直接是Flase，为了提高性能，后半部分不参与运算
    规律2：前面是ture，后面也为ture，整个为ture
    总规律：TT为ture，其他都为flase
'''
print("---"*10)
print(a >b and b< 1)
print("---"*10)
print(a > b and int(input("你想输入的数字："))<20) #测试短路；


'''
    or
     and
    可能取得值
    T - T -> T
    T - F -> T
    F - T -> T
    F - F -> F
    规律1：有一个为Ture，结果直接是Ture，为了提高性能，后半部分不参与运算
    规律2：前面是false，参与运算，后面也为false，整个为false
    总规律：FF为flase，其他都为ture
'''
print("---"*10)
print(a >b or b< 1)
print("---"*10)
print(a > b and int(input("你想输入的数字："))<20) #测试短路；

'''
    not取反
    flase返回ture
    ture返回flase
'''
print(not(a<b))
print("---"*10)

如果可以自己调试一下哦！！！

身份和成员运算符

1.身份运算符： is is not
是比较比较定义数据的id，可以是任何类型，除字符串等
2.成员运算符：in not in
是判断是否包含
两者输出都是布尔值（Flase和Ture）
上代码：

# 身份运算符 返回ture | false
# is  is not比较的是id（）
a = 'hhh'
b = 'hhh'
id(a)
id(b)
print(a is b)   #ture
print( a is not b)  #flase
print('==='*10)


print('==='*10)
a = 1
b = 1
print(a is b) #ture
print(a is not b)#false
print('==='*10)

print('==='*10)
a = [1,2,3]
b = [1,2,3]
print(a is b) #flase
print(a is not b)#ture
print('==='*10)


# == 比较的是内容
print('==='*10)
print(a == b)#ture
print ( a != b)#False
print('==='*10)


print('+++'*20)
# 成员运算符
a = [1,2,3]
print(1 in a)#ture
print(5 not in a)#ture

代码的运行图：

更新于：2022.07.17