快捷键应用：

1、Ctrl+D：疾速复制以后行
2、Ctrl+/：正文
3、Shift+ 回车：疾速回到下一行，无论光标在一行中的什么地位

配置：

1、python 解释器配置：File –> setting –> Project –> Python Interpreter
2、批改 py 文件名：鼠标放到 py 文件名字下面右击，Refactor –> Rename
3、装置库：pip3 install 库名

构造体：

1、class person：// 先 class 一个类（比如说人类 person）
2、def __init__(self,name,sex)：// 用 def 做一些定义 (定义人类的一些个性等，能够分多个去定义)
self.name = name // 代码 1
self.sex =sex // 代码 2
def say(self,word) // 还是定义
print(f'{self.name} 说：”{word}”‘)// 代码
3、张三 = person（’ 张三 ’,’ 男 ’）// 调用 person 类，根传入定义的值，(值外面只有 name 和 sex，所以传入的也只有 2 个‘张三’，‘男’)
4、zhangsan.say(‘ 你好 ’) // 调用类外面的函数，函数 say 外面有一个值 word，所以调用 say 也要有一个值，不然会报错

轻易记录点：
0、… 和 pass 的定义一样，成果一样。
1、单行在前方增加正文格局：2 空格 +#+ 1 空格 + 正文内容
函数与函数高低之间格局：要空两行
2、del：不是删除，是解除绑定关系
3、格式化代码(如果代码格局不标准，能够应用这个疾速使代码格局标准，依照的是 PEP8 标准)：Code -> Reformat Code

变量名规定：

1、只能是字母、数字、下划线的任意组合
2、不能用关键字命名
3、不能以数字结尾
5、python 其实能够应用中文的作为变量名的

变量名格调：

1、纯小写加下划线的形式（举荐应用）
2、驼峰体：每一个单词的首字母大写
7、变量值(3 个重要特色)：
id：反馈的是变量值的内存地址，内存地址不同 id 不同
type：不同类型的值用来示意记录不同的状态
value：值自身
变量名存在栈区，变量值存在堆区
8、字符串(字母)：须要用“”引起来
9、XX+()：代表运行一个性能。
查看 id 号：print(id(变量名))
查看类型：print(type(变量名))

is 与 ==

is：比拟左右两个值身份的 id 是否相等
==：比拟左右两个值是否相等

、理解：小整数池

1、这个值是 python 的范畴：【-5,256】
2、从 python 解释器启动那一刻开始，就会在内存中当时申请好一系列内存空间寄存好罕用的整数
3、在 pycharm 中，值的范畴会扩充。如果值超过了 python 的范畴，即便是 true，也要当做 false 来看

、常量：不变的量

1、python 语法中没有常量的概念，然而在程序的开发过程中会波及到常量的概念
2、小写字母全副为大写代表常量，这是一种约定、标准

数字类型(整型 int、浮点型 float)

int 和 float 之间能够相加

字符串：

作用：记录形容性质的状态、名字、一段话
定义：用引号 (“”,”,””” “””,”’ ”’) 蕴含的一串字符
字符串能够间接相加，但仅限于 str 和 str 相加，代表拼接操作。效率低不举荐应用。
字符串能够相乘，相当于反复。

（容器类型）列表 List、字典 Dict：

1、相同点：都能存多个值，称之为容器类型
2、不同点：

List

List 是用索引对应值，索引反馈的是地位 / 程序

dict

dict 是 Key 对应值，其中 key 通常为字符串类型，而 str 类型居右形容性功能，所以 key 对值能够有形容性功能
3、字典中的 value 值能够是任意类型，key 必须是不可变类型，所以 key 不能是列表或者字典

bool 型

1、用来记录虚实这两种状态
2、通常用来当做判断的条件，咱们将在 if 判断中用到它

输出和输入：

input

格式化输入：

1、值依照地位与 %s 一一对应，少一个多一个都不行 res=”my name is %s，age is %s %(howell,18)”, 括号里也能够用列表、字典形式填写，字典
2、%s 是 String 型，能够接管任意类型，%d 只能接管整型
3、如果用 %s 的形式，想再输入个 %, 须要：%s%%,

、字符串格式化输入：str.format。倡议用这个

1、依照 key=value 传值，res=”my name is {name}，age is {age}” .format(age=18,name=’howell’)
2、f
ege:x=input(“ 我的名字是：”)

y=input("我的年龄是：")

res = f’ 我的年龄是{y}，我的名字是{x}’ print(res)
18、算术运算符
1、+ 就是加
2、/ 后果带小数
3、// 只保留整数局部
4、% 取模，取余数
5、** 次方
19、比拟运算
1、> == >= < <= !=
20、赋值运算符
1、变量的赋值：=
2、增量赋值：a +=1(等于 a =a+1) / % * 都能够应用
21、链式赋值
1、z = y = x = 10
22、穿插赋值
1、m,n = n,m
23、解压赋值
1、*_

2、_*

24、可变不可变类型
1、可扭转：值变，id 不变。证实扭转的是原值，原值是能够被扭转的
2、不可变：值变，id 扭转。证实产生新的值，压根没扭转原值，证实原值是不能够被批改的
3、整型、浮点型、str、bool 是不可变类型，list dic 是可变类型
25、什么是条件？什么能够当做条件？为何要用条件？
1、显式布尔值：True False
2、隐式布尔值：所有数据类型，其中 0、None、空(空字符串、空列表、空字典) 代表的布尔值为 False
26、逻辑运算符
优先级：not > and > or
not:not 与紧跟其后的那个条件是一个不可分割的整体
and: 逻辑与，and 用来连贯左右两个条件，两个条件同时为真，最终后果为真
or：逻辑或，or 用来连贯左右两个条件，两个条件凡是有一个为真，最终后果为真；两个条件都是 False，后果才为 False
27、成员运算符 in，not in
1、判断一个字符串是否存在于一个打的字符串中
2、判断元素是否存在于列表
3、判断 key 是否存在于字典
28、身份运算符 is
1、判断的是 ID 是否相等
28、流程管制 if 判断
1、if 条件：

语句 1 

语句 2
……
print（）
2、语法 2
if 条件：

代码 1 

代码 2
……
else:
代码 1
代码 2
print（）
2、语法 3
if 条件：

代码 1 

代码 2
……
elif:
代码 1
代码 2
print（）
else:
代码 1
print（）
29、流程管制
1、循环之 while 循环
1、循环的语法与根本应用
2、死循环与效率问题
3、循环的利用
4、退出循环的两种形式
1、条件：
2、while+break
5、while 循环嵌套
6、while+continue
7、while+else

2、循环之 for 循环
for 变量名 in 可迭代对象：列表、字典、字符串、元组、汇合
1、for 循环的预发与根本应用
2、for 循环利用
3、for 循环嵌套
4、for+break
5、for+continue
6、for+else
总结 for 与 while
1、相同之处：都是循环，fou 循环能够干的事件，while 循环都能够干
2、不同之处：
while 循环称之为条件循环，循环次数取决于条件何时变为假
for 循环称之为 ” 取值循环 ”，循环次数取决于 in 后蕴含的值的个数
3、L = [‘a’,’b’,’c’]
for .. in L 循环中，不要用增删改的形式批改 L 的值，不然不晓得会呈现什么谬误

30、短路运算
31、深浅 copy
1、如何 copy 列表
1、浅 copy 是把整个内容都 copy 下来，对内容不加以辨别，对不可变类型没有影响，对可变类型有影响(如果批改了 copy 的内容，原内容也会被批改)
2、深 copy 是辨别内容，辨别可变和不可变类型。
3、字符串切片或者 copy，地址 ID 是不会变的，因为字符串不会扭转，然而列表的地址 ID 是不同的，因为外面的值能够扭转
32、根本数据类型及其内置办法
1、数字 int float
1、作用：
2、定义：
名字加括号 () 就是触发了一个性能，()外面能够传参数，ege:age = 10 等同于 age =int(10)
除了能够造本类型之外，还能够转换
3、类型转换
4、应用
2、字符串
3、列表
4、元组（tuple）不可变
5、字典
6、汇合（理解）
33、文件解决
1、字符编码
编码与解码
保障不乱码：以什么编码格局存就必须以什么编码格局取
2、文件解决
1、文件解决根本流程
2、with
3、操作模式
管制文件读写的模式：r(只读)、w(只写)、a(只写，追加写，写到前面)
管制文件读写内容的模式：t(以文本的形式读写文字)、b(二进制形式)，须要与下面的形式一起应用
4、操作文件的办法
5、管制文件指针的挪动
6、文件的批改的两种形式
34、for+range
for 循环管制循环次数：range()
35、for+continue
36、for 循环嵌套
for i in range(3):
print(循环，i)
for j in range(4):
print(再循环,j)
for 循环比 while 循环在循环取值上，有大的劣势，比 while 循环更简略
37、终止 for 循环只有 break 一种计划
38、print 补充：
39、进制：
二进制：就是只有 2 个数字，0 和 1
八进制：只有 8 个数字，0-7
十六进制：只有 16 个数，0-9、a、b、c、d、e、f
10 进制 –2 进制：除 2 取余法，倒着写就是 2 进制，应用 bin()性能转换，ege:print(bin(11)) 后果为：0b1011，这外面的 0b 就是代表二进制
10 进制 –8 进制：ege:print(oct(11)) 后果为：0o13，这外面的 0o 就是代表八进制
10 进制 –16 进制：ege:print(hex(11)) 后果为：0xb，这外面的 0x 就是代表 16 进制
2 进制 –10 进制：ege:print(int(‘0b1011’,2))
8 进制 –10 进制：ege:print(int(‘0b1011’,8))
16 进制 –10 进制：ege:print(int(‘0b1011’,16))
40、应用
int 和 float 没有须要把握的内置办法，他们的应用就是数学运算 + 比拟运算
python 中没有前面 + L 示意 long 型
41、字符串类型：str 能够把任何类型都转成字符串
1、内置办法：
1、按索引取值(正向取 + 反向取)：只能取
age:msg=”hello world”
正向取：print（msg[0]）或者 print(msg(5))
反向取：print(msg[-1])
只能取：msg[0]=”H”, 也就是不能批改 msg 外面的值
2、切片相当于 java 的三目运算符索引的拓展利用，从一个大字符串中拷贝出一个子字符串，新拷贝进去的字符串存到一个新的空间外面了，与原字符串没有任何关系
msg=’hello world’
res=msg[0:5]// 后果为 hello
步长：
res=msg[0:5:2]// 后果为：hlo
反向步长：
res=msg[5:0:-1]// 后果为：olle
倒着取：
res=msg[::-1] // 后果为：dlrow olleh

3、长度 len
msg= ‘hello world’
print(len(msg))
4、成员运算 in 和 not in

判断一个子字符串是否存在于一个大的字符串中

print(‘howell’ in ‘howell is No.1’)

移除空白 strip

移除字符串左右两侧的符号 strip

移除字符串左两侧的符号 lstrip

移除字符串右两侧的符号 rstrip

msg= ‘ howell ‘
res=msg.strip() . 进去，括号外面如果有 self，则认为不存在
print（msg）#不会扭转原来的值
print(res) #产生了新的值

• strip()，括号外面填写什么，就是去掉什么，能够写多个值，只会去两边的，不会去掉两头的
  如果登录账号时候，input 前面加上.strip(), 这样的话，就不会放心输出账号或者明码的时候呈现空格导致登录谬误了

  切分 split #把一个字符串依照某种分隔符进行切分，失去一个新的列表

  切分的是有法则的字符串

  切片等同于 copy 行为，而且相当于浅 copy

  1、默认分隔符是空格,

  2、如果分隔符是其余的，在 () 中填写宰割的符号即可
  3、如果字符串中有多个分隔符，只想宰割后面 2 个，那个在 () 中再加一个参数, 如：split(‘:’,2)
  age:info = ‘howell 18 male’
  res= info.split()
  join: 把列表拼接成字符串，和 split 相同
  age:l=[‘howell’,’18’,’male’]
  res= “:”.join(l) #依照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
  7、循环
  42、字符串全副改大写 lower，全副改小写,upper
  age:msg= ‘AbbbCCd’
  print(msg.lower()) # abbbccd
  print(msg.upper()) # ABBBCCD
  43、以什么什么来头，以什么什么结尾，startswith,endswith
  age: 应用办法同上
  44、replace
  msg=”you can you up ,no can no bb”
  print(msg.replace(“ 须要批改的字符 ”,” 要批改成的字符 ”,” 批改多少次 ”))
  45、isdigit #判断字符串是否都是数字组成
  用法同 42
  46、字符串理解操作
  【】【】【】【117 没看】【】】【】https://www.bilibili.com/vide…
  47、把同时能存多个值的类型称之为容器类型
  有序的类型称之为序列类型
  48、根本数据类型：
  1、list
  作用：按地位寄存多个值
  定义：在中括号内，逗号分隔开，多个类型的值。看类型用 type 性能
  类型转换：凡是可能被 for 循环遍历的类型都能够当做参数传给 list()转换成列表

2、tuple(不可变的列表)
3、dict
4、列表外面增加值：可变型的反对追加批改
XX.append(值)
5、插入值：
XX.insert(索引,’ 值 ’)
6、extend:
XX.extend(能被 for 循环的值)
49、删除
1、形式一：del 公共的删除办法，不是独有的，只是独自的删除，没有返回值（验证办法：a=del x[1] , 间接就报错了，不反对赋值语法）
2、形式二：x.pop(索引值) : 不指定索引，默认删除最初一个，删除后有返回值，返回的是删除的 h 值
3、形式三：x.remove(具体的元素)：依据元素删除，返回 None
50、须要把握的：
L = [1,2,3,’a’,’b’,’c’]
1、L.count(‘a’) // 查看 L 中有多少个 a
2、L.index(‘a’) // 查看索引，如果有多个雷同的值，返回第一个值的索引
3、L.clear(不须要传参数) // 清空
4、L.reverse(不须要传参数) // 将列表翻转
5、L.sort() // 默认从小到大排
L.sort(reverse = True) // 从大到小排
sort 就是比拟，列表内元素必须是同种类型。整型和浮点型能够在一起比大小。字符串也能够比大小，是依照 ASCI 表比拟的。
长的字符串比大小，是依照地位一个一个比照
列表也能够比大小，原力同字符串一样，然而对应地位的元素必须是同种类型
51、队列：先进先出(FIFO=first in first out) 先吃进去的货色先拉进去

堆栈：后进先出 (LIFO=last in first out) 后吃进去的货色先吐出来
51、元组：就是一个 ” 不可变的列表 ”
作用：依照索引 / 地位寄存多个值，只用于读不用于改
定义：() 内用逗号分隔开多个任意类型的元素
* 如果元组中只有一个元素，必须加逗号(,) 分隔开 age：t=(10,)
只有读的需要，没有改的需要，用元组
类型转换，可 list 一样的，凡是可能被 for 循环遍历的类型都能够当做参数传给 tuple()转换成元组
print(tuple(‘hello’))
print(tuple([1,2,3]))
print(tuple({‘a1′:111,’a’}))

52、字典类型：
定义：{}内用逗号分隔开多个 key:value , 其中 value 能够是任意值，然而 key 必须是不可变类型，且不能反复
d=dict() 这样就定义了一个字典 d=dict(x=1,y=2,z=3) // {‘x’:1,’y’:2,’z’:3}, 这样也造出一个字典
print(d,type(d)) // {} <class ‘dict’>
d={} 间接用{} 这样定义的是一个汇合
print(d,type(d)) // {} <class ‘dict’>

数据类型转换：
造字典：
疾速初始化一个字典
条件：keys=[‘name’,’age’,’gender’]，想造一个以 keys 值为 key，None 为 value 的字典
办法：d={}.fromkeys(keys,None)
53、字典
1、依照 key 取值：可存可取
2、针对赋值操作：key 存在，则批改
3、针对赋值操作：key 不存在，则创立新值
长度 len：
1、能够说计算的是 key 的个数 (key 值是不可变类型且不能反复)，也能够说计算的是 value 的个数
成员运算 in 和 not
in, 是依据 key 算的
删除：
1、通用的删除：del 拿不到返回值
2、pop 删除：d.pop(放入 key 值) 能够拿到返回值，返回的是删除 key 对应的那个 value 值
3、popitem 随机删除: 随机删除，返回元组元组内显示的是(刚删除的 key，刚删除的 value)
键 keys(), 值 value(), 键值对 items() => 在 python3 中失去的是 ” 老母鸡 ”（什么时候须要值什么时候取）
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))
54、须要把握的内置办法
d={‘k1’:111}
1、d.clear()
2、d.update()
3、d.get() key 不存在不报错，返回 None
4、d.setdefault() 如果查问的值在外面，则不产生扭转，如果没有则创立新的
1、key 有则不增加，返回字典中 key 对应的值
2、key 没有则增加，返回字典中 key 对应的值
55、汇合类型：
1、汇合类型
关系运算
去重（有局限性）
1、只能针对不可变类型去重
print(set(11122213e33313))
2、无奈保障原来的程序

2、总结与分类
有序 or 无序：有序又称之为序列类型
存一个值 or 多个值：存一个值称之为原子类型，存多个值称之为容器类型
可变 or 不可变
3、字符编码(实践多，论断少)
文本文件：人能辨认字符组成的文件
x=’ 上 ’，python 层面语法要用
4、文件解决根底
5、类型转换
set(‘hellollll’) set([‘a’,’b’,[‘c’,’d’]])
//{‘h’,’e’,’l’,’o’} 相当于底层调用了一个 for 循环，而且汇合中不能反复，所以多个 L 只显示一个 L
// 如果有个可变类型的，比方 set([‘a’,’b’,[‘c’,’d’]]) 中蕴含了 [‘c’,’d’] 会报错
6、内置办法：
1、大部分都是围绕着关系运算去做的
2、取交加：
res = A & B , 应用 & 可间接取出交加
3、取并集
A | B , // 应用 | 间接能够获取到并集
4、取差集
A – B //
5、取对称差集 两个用户独有的
A ^ B
6、父子集，(蕴含关系)