python

快捷键使用：

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 - 建议用这个

按照key=value传值，res="my name is {name}，age is {age}" .format(age=18,name='howell')

f

ege:x=input("我的名字是：")

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

res = f'我的年龄是{y}，我的名字是{x}' print(res)

算术运算符

1、+ 就是加
2、/ 结果带小数
3、// 只保留整数部分
4、% 取模，取余数
5、** 次方

比较运算

1、> == >= < <= !=

赋值运算符

1、变量的赋值：=
2、增量赋值：a +=1(等于a=a+1) / % * 都可以使用

链式赋值

1、z = y = x = 10

交叉赋值

1、m,n = n,m

解压赋值

1、*_
2、_*

可变不可变类型

1、可改变：值变，id不变。证明改变的是原值，原值是可以被改变的
2、不可变：值变，id改变。证明产生新的值，压根没改变原值，证明原值是不可以被修改的
3、整型、浮点型、str、bool是不可变类型，list dic是可变类型

什么是条件？什么可以当做条件？为何要用条件？

1、显式布尔值：True False
2、隐式布尔值：所有数据类型，其中0、None、空(空字符串、空列表、空字典)代表的布尔值为False

逻辑运算符

优先级：not > and > or
not:not与紧跟其后的那个条件是一个不可分割的整体
and:逻辑与，and用来连接左右两个条件，两个条件同时为真，最终结果为真
or：逻辑或，or用来连接左右两个条件，两个条件但凡有一个为真，最终结果为真；两个条件都是False，结果才为False

成员运算符 -- in & not in

1 、判断一个字符串是否存在于一个打的字符串中
2、判断元素是否存在于列表
3、判断key是否存在于字典

身份运算符 -- is

1、判断的是ID是否相等

流程控制if判断

语法1

if 条件：

语句1

语句2
......
print（）

语法2

if 条件：

代码1

代码2
......
else:
代码1
代码2
print（）

语法3

if 条件：

代码1

代码2
......
elif:
代码1
代码2
print（）
else:
代码1
print（）

流程控制

1、循环之while循环
1、循环的语法与基本使用
2、死循环与效率问题
3、循环的应用
4、退出循环的两种方式
1、条件：
2、while+break
5、while循环嵌套
6、while+continue
7、while+else

循环之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的值，不然不知道会出现什么错误

短路运算

深浅copy

1、如何copy列表
1、浅copy是把整个内容都copy下来，对内容不加以区分，对不可变类型没有影响，对可变类型有影响(如果修改了copy的内容，原内容也会被修改)
2、深copy是区分内容，区分可变和不可变类型。
3、字符串切片或者copy，地址ID是不会变的，因为字符串不会改变，但是列表的地址ID是不同的，因为里面的值可以改变

基本数据类型及其内置方法

1、数字 int float
1、作用：
2、定义：
名字加括号()就是触发了一个功能，()里面可以传参数，ege:age = 10 等同于age =int(10)
除了可以造本类型之外，还可以转换
3、类型转换
4、使用
2、字符串
3、列表
4、元组（tuple）不可变
5、字典
6、集合（了解）

文件处理

1、字符编码
编码与解码
保证不乱码：以什么编码格式存就必须以什么编码格式取
2、文件处理
1、文件处理基本流程
2、with
3、操作模式
控制文件读写的模式：r(只读)、w(只写) 、a(只写，追加写，写到后面)
控制文件读写内容的模式：t(以文本的方式读写文字)、b(二进制方式) ，需要与上面的方式一起使用
4、操作文件的方法
5、控制文件指针的移动
6、文件的修改的两种方式

for+range

for循环控制循环次数：range()

for+continue

for循环嵌套

for i in range(3):
print(循环，i)
for j in range(4):
print(再循环,j)
for循环比while循环在循环取值上，有大的优势，比while循环更简单

终止for循环只有break一种方案

print补充：

进制：

二进制：就是只有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))

使用

int和float没有需要掌握的内置方法，他们的使用就是数学运算+比较运算
python中没有后面+L表示long型

字符串类型 -- str可以把任何类型都转成字符串

内置方法：

按索引取值(正向取+反向取) -- 只能取

age:msg="hello world"
正向取：print（msg[0]） 或者print(msg(5))
反向取：print(msg[-1])
只能取：msg[0]="H",也就是不能修改msg里面的值
切片相当于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

长度len

msg= 'hello world'
print(len(msg))

成员运算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/video/BV1dN411f7Cn?p=117
  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、父子集，(包含关系)