Python

最新推荐文章于 2023-10-27 07:00:01 发布

原创最新推荐文章于 2023-10-27 07:00:01 发布 · 1.7k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python

摸鱼专栏收录该内容

3 篇文章

订阅专栏

Python Study

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ts8GA4cU-1624294083929)(D:\Eagle素材\设计素材.library\images\KN5I93E9GYJJV.info\Python_logo.png)]

Python默认路径

C:\Users\86178\AppData\Local\Programs\Python\Python36\

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vvLTwLN9-1624294083932)(D:\Eagle素材\设计素材.library\images\KN5HQORNG91ZR.info\Python3.png)]

使用pip这个工具安装的Python库或者包默认路径都在 : Lib --> site-packages

一般来说pip下载的源是国外的(下载速度相对较慢)

我们可以使用国内的源来进行下载

pip install pwntools -i https://mirrors.aliyun.com/pypi/simple/

# pip install 包名 -i 国内源名
清华
# https://pypi.tuna.tsinghua.edu.cn/simple/

中科大
# https://pypi.mirrors.ustc.edu.cn/simple/

阿里云   # (常用)
# https://mirrors.aliyun.com/pypi/simple/

豆瓣
# http://pypi.douban.com/simple/

如果你那儿的网络总是不给力，又不想每次手动添加，可以加在配置文件里一劳永逸。
# Windows：
在 windows 命令提示符（控制台）中，输入 %APPDATA%，进入此目录
在该目录下新建名为 pip 的文件夹，然后在其中新建文件 pip.ini。（例如："C:\Users\Administrator\AppData\Roaming\pip\pip.ini"）
在文件中填入一下内容并保存（可替换为上述不同的镜像地址）：
[global]
index-url = http://pypi.douban.com/simple
[install]
trusted-host=pypi.douban.com

# Linux / Mac：
文件地址为 ~/.pip/pip.conf,其余的差不多都相同


pip -V 								 # 查看pip的版本信息
pip list 							 # 列出匹配管理的包有哪些
pip install 包名 (pip install redis)  # 安装包
# pip install 包名==版本号            // 安装特定的版本包
pip uninstall 包名                    # 卸载包
pip freeze > requirements.txt        # 将项目依赖的包输出到指定的文档中requirements.txt
# pip install -r requirements.txt 	 # 使用pip安装requirements.txt中依赖的文件

syntaxError #语法错误
NnameError  #名字错误
# Python 2 对中文的支持较差 , 如果要在Python 2.x程序中使用中文字符或者中文变量,则需要在Python源程序的第一行增加"#coding:utf-8",当然别忘了将源文件保存为utf-8字符集

后缀

# py
以 py 扩展名的文件是 Python 源码文件，由 python.exe 解释，可在控制台下运行。可用文本编辑器读写。

# pyc
以 pyc 为扩展名的是Python的编译文件。其执行速度快于 py 文件且不能用文本编辑编辑查看。所以 pyc 文件往往代替 py 文件发布。
Python 在执行时，首先会将 py 文件中的源代码编译成 PyCodeObject 写入 pyc 文件，再由虚拟机执行 PyCodeObject。当 Python 执行 import 时会先寻找对应的 pyc或 pyd（dll）文件，如果没有则将对应的py文件编译写入 pyc 文件。pyc文件也可以通过  

# python -m py_compile src.py 生成。

# pyw
pyw 文件与 pyc 文件相似，但 pyw 执行的时候不会出控制台窗口。开发（纯图形界面程序）时可以暂时把 pyw 改成 py 以调出控制台窗口调试。

# pyo
pyo 是优化编译后的程序,不能用文本编辑器编辑。 python -O source.py 即可将源程序编译为 pyo 文件。

# pyd
pyd 一般是 Python 外的其他语言如 C/C++ 编写的 Python 扩展模块，即 Python 的一个动态连接库，与 dll 文件相当。在Linux系统中一般为.so文件
————————————————

1.变量

所谓的声明变量实际上就是向内存申请一段空间

常量 : 固定的值,值不能发生改变
变量 : 里面存放的值随时可以发生改变

Python是弱类型语言 :声明的变量赋什么值这个变量就是什么类型的.

type(变量名)   # 返回该变量的类型
# 测试python的弱类型
money = 100
print(money, type(money))
money = '100元'
print(money, type(money))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lddFSLB2-1624294083934)(D:\Eagle素材\设计素材.library\images\KN4HD2USQORKV.info\Python1.png)]

变量命名规则

可以以字母,数字,_命名不能以数字开头
严格区分大小写
不能使用python的关键字命名

查看python有哪些关键字

import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xgI0HjSL-1624294083937)(D:\Eagle素材\设计素材.library\images\KN4LM3YQDQ7Y6.info\Python2.png)]

变量命名建议

驼峰式 : getName payMoney
- 如果一个名字是由多个单词组成的,则除第一个单词之外以后的每个单词的首字母要大写
- 类: (GetName) 如果定义类名,每个单词的首字母都要大写
下划线式 : pay_money
- Python中变量的,函数命名
- get_name (Python推荐)

2. print语句的使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cfbjEDh7-1624294083940)(D:\Eagle素材\设计素材.library\images\KN5JA0Y1BHPA3.info\Python4.png)]

我们使用 help(print) 来查看print语句

单词:
# Built-in (builtins)   内置;固有  
-------------------------------
print() # 为Python里的一个内置函数

print(r'Hello\the\dog') # r" raw 原样输出字符串的内容,即使有转义字符也不会转义.
print('HELLO','WORLD','YES')
print('HELLO','WORLD','YES',sep='+')
print('HELLO','WORLD','YES',end='')
print('HeLLO','WORLD','YES',sep='+',end='')
# 含有占位符时不能使用sep和end
'''
输出:
Hello\the\dog
HELLO WORLD YES
HELLO+WORLD+YES
HELLO WORLD YESHeLLO+WORLD+YES

'''

print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

sep 参数用来表示输出时,每个值之间使用哪种字符作为分隔,默认使用空格作为分隔符
end 当执行完一个print语句以后,接下来要输出的字符.默认是换行符.

[ 在Python里三引号的作用 ]

保留格式的字符串使用
作为注释使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yZN7Wi8M-1624294083941)(D:\Eagle素材\设计素材.library\images\KN5YX1P7AJPLV.info\Python5.png)]

3.格式化输出

方式

使用占位符
使用format函数

使用占位符

# 在Python里我们可以使用'+'符号对字符串进行拼接  str + int --> error
name = 'zhouhaobusy'
address = 'beijing'
phone = '1234512345'
print("名字是:'+name+'地址是:'+address+'联系方式:'+phone")
# 使用占位符 
print("名字是:%s 地址是:%s 联系方式是:%s" %(name,address,phone)) #输出相同

# 强制转换 # 强制转换中一定要有一个变量(容器)去接收转换后的值
# 
age = 100    # age = str(age) //将int类型转换为字符串类型
age = '100'  # age = 
# int(18.88) ==> 输出:18

------------------------------------------------------------------------

    // 1、%d 为整数占位符，10进制表示，默认有符号，占4字节
   
    // 2、%u 为整数占位符，10进制表示，无符号表示，最高位算作值的一部分
   
#   // 3、%o 为整数占位符，8进制表示

#   // 4、%x 为整数占位符， 16进制表示
   
    // 5、%f为浮点数占位符
  
    // 6、%s为字符串占位符
 
    // 7、%c为字符占位符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pDUMkQ5n-1624294083943)(D:\Eagle素材\设计素材.library\images\KN6VJ3PFB9YWJ.info\Python6.png)]

使用format函数

format函数的说明

------------------------------------------------------------------------
format(self, *args, **kwargs): # known special case of str.format
        """
        S.format(*args, **kwargs) -> str
        
        Return a formatted version of S, using substitutions from args and kwargs.
        The substitutions are identified by braces ('{' and '}').
        """
------------------------------------------------------------------------

name = 'zhouhaobusy'
age = 18
grade = 100.5
message = '我的名字叫{},今年年龄是{}岁,成绩是{}分'.format(name, age, grade)
print(message)
------------------------------------------------------------------------
# 也可以使用format格式化位数
print("g({0:.3f}) = {1:.3f}".format(x, y))

4. 输入语句的使用

input函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MbWcgl9V-1624294083944)(D:\Eagle素材\设计素材.library\images\KN7C5FB3JV307.info\Python8.png)]

# prompt : 提示,促使,驱使,迅速
# 格式: 变量 = input("提示:")
使用input获取的内容都是字符串型的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vMIaChK5-1624294083946)(D:\Eagle素材\设计素材.library\images\KN8G5B9QSB29W.info\Python9.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PyYI5L4L-1624294083947)(D:\Eagle素材\设计素材.library\images\KNA2E6ENOJLWH.info\Python10.png)]

5. 运算符

赋值运算符&内存分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yBjGotJM-1624294083948)(D:\Eagle素材\设计素材.library\images\KNA2E8AF242ZU.info\Python11.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r81Qq7XI-1624294083949)(D:\Eagle素材\设计素材.library\images\KNA71ITMVG83R.info\Python12.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-igDvKWJV-1624294083950)(D:\Eagle素材\设计素材.library\images\KNA9SGYTI17ET.info\绘图1.jpg)]

# 扩展后的赋值运算符
+= -= *= /= ....
num = 10
num += 5 # num = num + 5
print(num) # 15

str1 = 'Hello'
str1 += 'World' # 等价于 : str1 = 'Hello' + str1 此时的'+'就是连接符
print(str1) # HelloWorld

算数运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QTpNxs0C-1624294083951)(D:\Eagle素材\设计素材.library\images\KNACJNQMQ67BE.info\Python14.png)]

关系运算符

# 关系运算符: == != >= <= > < 'is' 'is not'

# is 和 is not 是通过比较内存来返回相应的bool值的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mlD1nrmE-1624294083952)(D:\Eagle素材\设计素材.library\images\KNBHMMTWZA8R4.info\Python15.png)]

逻辑运算符

# and 逻辑与
# or  逻辑或
# not 逻辑非
# 逻辑运算符的运算结果也是返回True False

# 取反 ~

# xor异或运算  ^    相同为0 不同为1
# 左移        <<    m<<n 相当与m乘以2的n次方
# 右移        >>    m>>  相当与m除以2的n次方

三目运算符

格式: 结果 if 表达式 else 结果

# 格式: 表达式 ? 真语句 : 假语句
# 在Python里这种格式并不支持
a = 5
b = 6
result (a+b) if a<b else (b-a)
# 表达式1 : (a+b)
# 判断语句 : a<b
# 表达式2 : (b-a)
# 如果 a<b为真则执行表达式1 若为假则执行第二条语句
'''
判断表达式是true还是False
如果是True则将if前面的内容进行运算,并将结果赋值给result
如果是False则将if后面的内容进行运算,并将结果赋值给result

'''

运算符的优先级

判断语句

IF语句

'''
if语句里不接关系运算符 如上面 if username:
 # 判断变量是'' 0 None 默认为False
 # 如果变量有值eg: 'abc' '123'... ,则认为是true
'''
username = ''
if username:
	print("Welcome!")
print("OK!")

'''
if num:
	print('----')
等效于:
if num!=0:
	print('----')
'''

四种结构

# range(n) ---> 0 ~ n-1
# range(m,n) ---> m ~ n-1
# range(m,n,step)

循环语句

# 如果 for 和 else 同级 


for i in range(4):  # ,从0开始 0 1 2 3

# pass
# break 退出
# while 语句

for i in range(4):
    ....
else:
    print("这里的语句是循环 ")

字符串的操作

基本操作

# 我们可以使用 'in' 和 'not in' 来判断子字符串是否在父字符串里
# 使用''' ''' 来格式化字符串

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AVa0hVIQ-1624294083954)(D:\Eagle素材\设计素材.library\images\KNFX998G4FF9H.info\Python16.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xclXQE49-1624294083955)(D:\Eagle素材\设计素材.library\images\KNFXS1OQIDEPA.info\Python17.png)]

# str[start:end:方向和步长]
	1  表示从左向右
    -1 表示从右往左   
# str = 'Hello World' 
	H   e   l   l   o       W   o   r   l   d
	0   1   2   3   4   5   6   7   8   9   10
   -11 -10 -9  -8  -7  -6  -5  -4  -3  -2   -1                           
# 练习 : Hello World
1. 逆序输出 World
2. 正向输出 Hello
3. 逆序输出 Hello World
4. 打印获取 oll
5. 打印获取 llo Wo

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ig3Z6JBN-1624294083956)(D:\Eagle素材\设计素材.library\images\KNH9U1RPICZVY.info\Python18.png)]

内建函数

: 声明一个字符串,默认可以调用内建函数 (系统准备好的一些函数)

1. 大小写相关

swapcase() # 将字符串中大写转换为小写，小写转换为大写 |
capitalize() # 将字符串的第一个字符转成大写
title() # 将字符串每个单词的首字母转成大写
upper() # 将字符串全部转换成大写的表示形式
lower() # 将字符串全部转换成小写的表示形式

如何函数前面带了 ’ is ’ 则返回的是布尔类型

# istitle() isupper() islower() 

istitle()  # 判断字符串每个单词的首字母是否为大写
isupper()  # 判断字符串的每个字符是否全部为大写
islower()  # 判断字符串的每个字符是否全部为小写

验证码例题

# 验证码的生成
import random

code = ''
code_pool = 'QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890'
# print(len(code_pool)) # 求字符串的长度 len(str) 返回的是一个整形的数值
for i in range(4):
    code_tmp = random.randint(0, len(code_pool) - 1)  # 0 ~ 61 随机生成一个数字

    code += code_pool[code_tmp]  # 将字符进行拼接
print('您的验证码是: {}'.format(code))
while True:  # 循环
    user_code = input("请输入验证码:")
    if user_code.lower() == code.lower():  # 使用lower()这个内置函数将验证码和用户输入的字符都转换成小写
        print("验证码输入正确")
        break
    else:
        print("对不起,验证码输入错误")

2. 查找,替换相关

find() # 返回值为-1则代表没找到 (如果可以找到则返回字母第一次出现的位置)
rfind() # 从右查找
lfind() # 从左查找
index() # 与find()方法一样,只不过如果str不在字符串中会报一个异常**(返回索引下标)**
- rindex()
- lindex()
replace() # 替换 replace(self, old, new, count=None)

3. 编码相关

encode() # 编码
decode() # 解码

4. 判断相关

startswith() # 判断字符串是否以…开头
endswith() # 判断字符串是否以…结尾
isalpha() # 字母判断(字符串里全为字母才返回真)
isdigit() # 数字判断(字符串里全为数字才返回真)

startswith() endswith() 返回值都是布尔类型 True False

5. 连接与分割

join() # 以指定字符串作为分隔符,分割字符串 (将什么加入到什么中)
split() # 以 str 为分隔符截取字符串

# join() : '+'.join('abcd')  将abcd每个字母用'+'连接构成一个新的字符串
new_str = '+'.join('abcd')
print(new_str)

# python里列表 list1 = ['a','b','c','d']
list1 = ['a','b','c','d']
result = '-'.join(list1)
print(type(result))  # 返回的是str类型

# 
s = 'Hello World Ha Ha'
result = s.split(' ')
print(result)  # 返回的是列表类型 ['Hello', 'World', 'Ha', 'Ha']
result = s.split(' ',1)   # ['Hello', 'World Ha Ha']

6. 其他

count(args) # 返回字符串中指定args的个数
strip() # 去除字符串两侧的空格
lstrip() # 去除字符串左侧的空格
rstrip() # 去除字符串右侧的空格

s = 'Hello World Ha Ha'
str_count = s.count(' ')
print(str_count)  # str_count = 4



# 用户输入字符
c = input("请输入一个字符: ")
 
# 用户输入ASCII码，并将输入的数字转为整型
a = int(input("请输入一个ASCII码: "))
 
 
print( c + " 的ASCII 码为", ord(c))
print( a , " 对应的字符为", chr(a))

列表

列表中可放元素 (所有数据类型)
- 整形
- 字符串类型
- 浮点型
- 列表
- 元祖
- 字典
- 对象

列表的类型转换

使用 **list( ) ** 这个函数实现强制转换

# 类型转换
str()		# 强制转换为字符型 
int()		# 强制转换为整形

list()		# 强制转换为列表型
# 举例
iterable  可迭代的   # for ... in里面可以循环就是可迭代的

s = 'abcd'
result = list(s)  # ['a','b','c','d']

s = range(1,10,3)
result = list(s)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZZf7YCvO-1624294083957)(D:\Eagle素材\设计素材.library\images\KNMWM7CRJCWBQ.info\Python19.png)]

列表中可以使用的符号

1. +       # 合并列表
2. *       # [] * num
# 举例
list1 = ['a','b','c']
result = list1 * 3  # result --> ['a','b','c''a','b','c''a','b','c']
3. in      #
4. not in  #
5. is      # 判断列表的地址是否相同
6. not is  #

基本操作

# 声明
names = ['tom','jack','lucy','ironman']  # 列表

# 元素获取使用 : 下标 索引
print(names[0])
print(names[1])
# 获取最后一个元素
print(names[-1])   # 支持负号

# 删除

del list[index]  # 删除下标为index的元素

# 结合循环
for name in names:
    print(name)
# 查询names里面有没有保存钢铁侠 

for name in names:  # name = 'tom' name = 'jack'
    if name == 'ironman':
        print('Yes')
        break
	else:
        print('No')
        
# 列表也支持切片
list1 = ['one','two','three','four','five','six','seven','eight']
print(list1[3:6]) # 将截取的结果再次保存在一个列表中 ['four','five','six']
print(list1[-3:-1]) # ['six','seven','eight']

# 反方向
print(list1[-1::-1])
print(list1[-1::-2])  # 步长为2且反方向

w = input("请输入一个单词:")
i = 0 # 表示下标
l = len(words)
while i<l:
    if w in words[i]:
        del words[i]
        l-=1
        # i-=l
        continue
    i+=1
print(words)

内建函数

添加更新

append() # 末尾追加
extends() # 类似与列表的合并 符号 ‘+’ 也可以用于列表的合并
insert() # 指定位置插入

删除

del list[index] 删除列表中下标为index的元素

remove(e) # 删除列表中第一次出现的元素e ,返回值是None

如果没找到要删除的元素则包出异常
pop() # 弹栈 ,移除列表中最后一个元素,返回值是删除的那个元素

默认是删除最后一个,但是也可以指定index(下标) 删除
clear() # 清除列表 (里面所有元素全部删除)

其他

max() # 返回列表里最大的数
min() # 返回列表里最小的值
sorted() # 排序(默认是升序排列) ascending order(升序) descending order(降序)
sum() # 对列表中的数进行求和
reverse() # 反转列表
len() # 返回的是列表的长度值(int)
count() # 返回指定元素的个数
enumerate() # 遍历列表 (下标 + 值)

# 排序
1. sorted(list,reverse=True) # 返回的是列表类型的
2. list.sort(reverse=True|False)

# enumerate的用法
'''
语法:
enumerate(sequence, [start=0])
参数:
sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
-------------------------------------------
# 使用普通的for循环:
-------------------------------------------
i = 0
seq = ['one', 'two', 'three']
for element in seq:
	print(i, seq[i])
	i +=1
# 输出结果:
0 one
1 two
2 three

# for循环使用enumerate:
------------------------------------------
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
	print (i, element)
# 输出结果:
0 one
1 two
2 three

'''

元组(tuple)

特点:

定义的符号为: ()
元组中的内容不可修改
关键字: tuple

定义只有一个元素的元组应该在后面加一个 , 否则和没加括号一样

# 拆包,装包
x,*y = (1,2,3,4,5,6) # x = 1  y = [2,3,4,5,6]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nxe9AZX8-1624294083959)(D:\Eagle素材\设计素材.library\images\KNPUASSZ2A4UM.info\Python20.png)]

字典

基本操作

与列表的对比

# 定义
dict1 = {}      # 空字典
# 可以使用dict()这个函数进行强制转换
dict2 = dict()  # 空字典 
list1 = list() # 空列表 
tuple1 = tuple() # 空元祖
dict3 = {'ID':'123','name':'zhouhao','age':18}
dict4 = dict([('name','zhouhao'),('age',18)])

# 增加
'''
列表:
list1 = []
list1.append(element)

字典:
disct1 = {}
dict1[key]=value

'''
dict5 = {}
# 格式: dict5[key]=value
dict5['brand'] = 'play boy'   #{'brand':'playboy'}

# 修改
'''
列表:
list1[index] = newvalue # 列表使用下标

字典:
dict1[key] = newvalue   # 字典使用键值对

'''
dict1['brand'] = 'apple'

# 查询
'''
列表:
list1[index]   ----> element

字典:
dict1[key]     ----> value

'''
# 我们也可以使用 in 来对字典中key进行判断
dict1 = {'student1': 123, 'student2': 98, 'student3': 89}
print('student1' in dict1) # 输出 True
print('Alice' in dict1)    # 输出 False

遍历字典

dict1 = {'name':'zhouhao','ID':3,'grade':100}
for i in dict1:
    print(i)  # 输出:name ID grade 
# 默认遍历字典输出的为字典内所有的key
# 我们可以搭配函数对其进行遍历
items() values() keys()
'''
for i in dict1.items():
	print(i) #输出: ('name', 'zhouhao') ('ID', 3) ('grade', 100)

'''
for key,value in dict1.items():
    print(value) # 输出 zhouhao 3 100

删除

'''
列表:
list1=[1,2,3,4,5,6]
del list[1]
print(list1)

字典:
dict1 = {'Alice': 123, 'Mark': 98, 'Tom': 89}
del dict1['Alice']
print(dict1)
# del dict1['LiHua']  # KeyError
'''
# 字典的内置函数 : 删除
# remove()  --> 报错 字典内不能使用这个函数!
1. pop()
2. popitem()
3. clear()
# 例子

使用zip函数, 把key和value的list组合在一起, 再转成字典(dict).


keys = ['a', 'b', 'c']
values = [1, 2, 3]
dictionary = dict(zip(keys, values))
print dictionary

"""
输出:
{'a': 1, 'c': 3, 'b': 2}
"""

内置函数

1. items()

作用: items() 函数以列表返回可遍历的(键和值) 。
将字典的键值对转成列表保存的形式

dict1 = {'name':'zhouhao','ID':3,'grade':100}
print(dict1.items())
# 输出：dict_items([('name', 'zhouhao'), ('ID', 3), ('grade', 100)])

# 可以搭配循环对字典进行遍历

2. values()

取出字典中所有值,并将其保存到列表中

dict1 = {'student1': 123, 'student2': 98, 'student3': 89}
print(dict1.values())
#输出: dict_values([123, 98, 89])

# 求所有学生考试成绩的平均分
dict1 = {'student1': 123, 'student2': 98, 'student3': 89}
scores = sum(dict1.values())
lens = len(dict1.values())
aver_dict1 = scores / lens
print(aver_dict1) # 103.33

3. keys()

获取字典中所有key键

dict1 = {'student1': 123, 'student2': 98, 'student3': 89}
print(dict1.keys())
# 输出: dict_keys(['student1', 'student2', 'student3'])

4. get()

获取字典中相应key对应的value

# 我们知道根据key获取值,如果key在字典里没有存在则报出keyError
dict1 = {'student1': 123, 'student2': 98, 'student3': 89}
print(dict1.get('student1')) # 123
'''
get(key)   ---> value  如果取不到值也不会报错,真返回None
get(key,default)   ---> value 如果能够取到值则返回字典中的值,如果取不到则返回default的值.
'''

dict1 = {'Alice': 123, 'Mark': 98, 'Tom': 89}
# result = dict1['lihua'] # KeyError: 'lihua'
result = dict1['Alice']
print(result)  # 123
result = dict1.get('Mark')
print(result)  # 98
result = dict1.get('lihua')
print(result)  # None
result = dict1.get('lihua',100)
print(result)  # 使用默认值100 输出: 100

5. pop()

根据key删除字典中的键值对,(只要删除成功,则返回键值对的value)
pop的默认值,往往是在删除的时候没有找到对应的key,则返回default默认值

# pop(key,[default])
dict1 = {'Alice': 123, 'Mark': 98, 'Tom': 89}
val = dict1.pop('Mark')
result = dict1.pop('LiHua','字典中没有此键') # 字典中没有此键
print(dict1) # {'Alice': 123, 'Tom': 89}
print(val)   # 98

6. popitem()

随机删除字典中的键值对(一般是从末尾开始删除元素)
返回值为字典中被删除的键值对 ( 而pop() 返回的只是值 )

dict1 = {'Alice': 123, 'Mark': 98, 'Tom': 89}
val = dict1.popitem()  
print(dict1) # {'Alice': 123, 'Mark': 98}
print(val) # ('Tom', 89) --- > 与pop()这个函数的区别

7. clear()

清空字典中所有键值对

dict1 = {'Alice': 123, 'Mark': 98, 'Tom': 89}
result = dict1.clear()
print(result) # None
print(dict1)  # {}

8. update()

将两个字典进行合并
dict1.update(dict2) # dict1将为合并的那个字典


dict1 = {'Alice': 123, 'Mark': 98, 'Tom': 89}
dict2 = {'Lihua': 150, 'Mark': 100, 'Bob': 120}
result = dict1.update(dict2)
print(result) # None
print(dict1) 
# 输出: {'Alice': 123, 'Mark': 100, 'Tom': 89, 'Lihua': 150, 'Bob': 120}
'''
1. 如果合并的两个字典中有相同的key,则默认替换为后面那个字典key对应的值
(如上面例子中的Mark)
2. 合并之后,前面的那个字典,将变为合并之后的字典
'''

9. fromkeys()

形式:dict.fromkeys(seq,[default])

将seq转成字典的形式,如果没有指定默认的value则使用None
如果指定default,则用default替代None这个value值

list1 = ['a','b','c','d']
new_dict = dict.fromkeys(list1)
print(new_dict) 
# 输出: {'a': None, 'b': None, 'c': None, 'd': None}
new_dict = dict.fromkeys(list1,100)
# 输出: {'a': 100, 'b': 100, 'c': 100, 'd': 100}

其他

value查key

将字典列表化

student = {'Mark': '100', 'Mills': '120', 'Tom': '130', 'Alice': '140'}
result = list(student.keys())[list(student.values()).index('130')]
print(result)  # 输出为Tom

定义一个函数

def get_key (dict, value):
    return [k for k, v in dict.items() if v == value]
get_key (student, '120')

把字典的key与val互换

new_dict = {v : k for k, v in student.items()}
new_dict ['100']
# 输出:Mark

# 读入一个字符串，统计字符串中每个字符出现的次数，输出结果按次数降序排序。
a = input()
result: dict = {}
for i in set(a):
    result[i] = a.count(i)
b = sorted(result.items(), key=lambda x: x[1], reverse=True)
for i in b:
    print("{} : {}".format(i[0], i[1]))

集合

关键字: set (无序的不重复元素)

# 声明集合
set1 = set() # 创建空集合,(只能使用set())
set2 = {1,2,5,4} 
print(type(set1)) # set
print(type(set2))　# set
# 字典: {key:value,key:value...}
# 集合: {element1,element2,element3...}

# 应用: 如果有一个列表快速去重使用: set()
list1 = [1,2,3,4,3,3,3,2,4,5,6,7,5,4,3]
s2 = set(list1) # {1, 2, 3, 4, 5, 6, 7}

基本操作

# 增删改查
# 增加元素
1. # 使用add()函数 (只能添加一个值)
'''
set1 = set()
set1.add('Hello')
set1.add('Luck')
print(set1)  # {'Hello','Luck'}
'''
2. # 使用update()函数
set1 = {'lucy', 'bob', 'alice'}
set2 = {'mark', 'luis', 'alice'}
dict1 = {'student': 'hellen', 'teacher': 'hennay'}
str1 = 'zhouhao'
set1.update(str1) # {'z', 'a', 'bob', 'h', 'o', 'alice', 'lucy', 'u'}
'''
update()函数内的类型为字符串时会把字符串拆分成每个字母,(不会重复)
如果为字典的话,则默认会将字典的key放入其中.

'''
# set1.update(set2)

# set1.update(dict1)

# 删除
# 使用 remove() pop() clear()  discard() 函数
discard   丢弃,废弃,抛弃
1. remove() # 如果元素存在则删除,不存在则报错KeyError
2. pop() # 随机删除(一般删除第一个元素)
3. clear() # 清空
4. discard # 类似于remove()  但是在移除不存在的时候不会报错

交并差集运算

set1 = {1,2,3,4,5}
set2 = {4,5,6,7}
- : set1 - set2 # 差集      difference()
& : set1 & set2 # 交集      intersection()
| : set1 | set2 # 并集      union()
^ : set1 ^ set2 # 对称差集   symmetric_difference()
# symmetric : 对称的
set1 = set1.difference(set2)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xnwfrsdc-1624294083961)(D:\Eagle素材\设计素材.library\images\KOF2XQTAXAXB1.info\集合.png)]

可变类型与不可变类型

可变: 对象所指向的内存中的值是可以改变

可变类型: dict list

不可变: 对象所指向的内存中的值是不可以改变的

不可变类型: int str float tuple

函数

将重复的代码,封装成函数,只要使用,就可以调用函数,从而达到增强代码的模块化和提高代码的重复利用率.

ALT + ENTER # 快速提醒, 快速导入包

# Python函数的格式
def 函数名([参数,参数...]):
    函数体(重复的代码)

注意: 1. 必须使用关键字def 2. 函数提注意缩进 3. 函数名() 4. 冒号

参数

可变参数

# 可变参数 
# 注意: 可变参数必须放在后面
def add(*args):    # 相当 
    print(args)
add()  # 空元祖
add(1,2,3)
add(1,2,3,4)

def add(name,*args):  # 可支持多个参数(name,age,*args)
    result = sum(args)
    print('%s计算的结果为:%s'%(name,result))
add('Alice',1,2,3,4,5)  # 结果为 Alice计算的结果为:15

关键字参数

# 关键字参数: key=value
def add(a,b=0):  # 如果没指定第二个参数,默认为value值
    result =a+b
    print(result)
add(5)    #  5
add(4,9)  # 此时的9 

# 可以通过key=value指定特定的值

students = {'001':('Alice',19),'002':('Bob',21),'003':('Mark',31)}
def print_boy(persons):
    if isinstance(persons,dict):
        values = persons.values()
        print(values)
        for name,age in values:
            print('{}的年龄是:{}'.format(name,age))
           
# **kwargs就说明:只要函数体外给函数送值,送的值就必须是 key = value

students = {'001':('Alice',19),'002':('Bob',21),'003':('Mark',31)}
def func(**kwargs):  # key word arguments
    print(kwargs)
    
func(**student)   #拆包


# 我们可以在要传递的参数上加一个或两个*号来对列表,元祖,字典进行拆包
def func(*args, **kwargs):
    print(*args)
    if isinstance(args, list):
        for i in args:
            print(args)
    else:
        print('args is not a list!')

    for v, k in kwargs.items():
        print('这个字典的键为{},值为{}'.format(k, v))


list1 = [1, 2, 3, 4, 5]
dict1 = {'luis': 100, 'rose': 150}
func(*list1, **dict1)

'''
[1, 2, 3, 4, 5]
args is not a list!
这个字典的键为100,值为luis
这个字典的键为150,值为rose
'''

返回值


def main(**kwargs):
    key_list = []
    value_list = []
    for k, v in kwargs.items():
        key_list.append(k)
        value_list.append(v)
    return key_list, value_list


dict_grade = {'zhouhao': 100, 'zhangyuchao': 0, 'Mark': 50}
# result = main(**dict_grade)
# print(result)  # 返回类型  --> 元组
key, value = main(**dict_grade)
print(key, value, sep='---')

return 返回值

return后面可以是一个参数接收 result = add(1,2)
return 后面也可以是多个参数,如果是多个参数则底层会将多个参数先放在一个元组中,将元祖作为整体返回

接收的时候也可以是多个:

key, value = main(**dict_grade)
print(key, value, sep='---')

匿名函数

格式: lambda 参数1,参数2… : 运算

作用:简化函数定义

func = lambda x, y: x ** y  # lambda 参数:返回结果
result = func(2, 3)
print(result)


# 匿名函数作为参数
def main(x,y,func):
    print(x,y)
    print(func)
    result = func(x,y)
    print(result)
main(1,2,lambda a,b:a+b)

面向对象

专有名词

类
对象
属性
方法

# 所有的类名要求首字母大写, 多个单词使用驼峰式命名法
# ValueError TypeError StopIterable
# 在python里默认所有类继承 object
# 格式:
'''
class 类名[(父类)]:
    属性: 特征

	方法: 动作

'''
class Phone:
    brand = 'iphone'


print(Phone)

# 使用类创建对象
object1 = Phone()  # 对象object1
object2 = Phone()  # 对象object2
print(object1)
print(object2)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dv0RymRg-1624294083962)(D:/Eagle素材/设计素材.library/images/KPR28G2FU3KZ2.info/Python25.png)]

对象属性

构造器&_init_

class Phone:
# 魔术方法之一 格式: __名字__()
    def __init__(self)   # init 初始化,初始的

类方法


@classmethod
def test(cls):   # cls -->class
    print(cls)
    print(cls.)

特点

定义需要依赖装饰器
类方法中参数不是一个对象,而是类

print(cls) # <class ‘__main__.Dog’>
类方法中只可以使用类属性
类方法中不能使用普通方法

作用

因为只能访问类属性和类方法,所以可以在对象创建之前,完成一些动作和功能.

2.输入语句的使用

python里使用input内置函数接收用户的输入

input() —括号里写提示信息

3.不同进制数据的表示方式

python里的数据类型

整型(int) 浮点型(float) 复数(complex)

字符串(str) 布尔(bool) 列表(list) 字典(dict) 集合(set) 元组(tuple)

a = 0b101010101  #以0b开头的数字表示的是二进制(BIN)
a = 0o101010101  #以0o开头的数字表示的是八进制(OCT) [在python2里以0开头得数字也是八进制]
a = 101010101    #python默认使用10进制(DEC)
a = 0x2abcdef19  #以0x开头的数字表示的是十进制(HEX)

使用内置函数实现进制转换

c = 100  (在pycharm里可以使用bin(c).print快速输入代码)
print(bin(c)) #使用bin内置函数可以将数字转换为二进制
print(oct(c)) #使用oct内置函数可以将数字转换为八进制
print(hex(c)) #使用hex内置函数可以将数字转换为十六进制

pass关键字在python里没有意义,只是单纯用来占位,保证语句的完整

python里可以使用连续的区间判断

eg: 60 > score >=0

ctrl+alt+l :快速格式化代码

alt/ctrl+shift+上下箭头 :上下移动一行代码

ctrl+/ 快速注释

ctrl + 左右键 :快速跳转到行首/行尾

一次性选中并修改多个相同的变量

1.将光标置于要修改的变量名后面
2.多次按alt+j，这样就可以在相同的变量名后面添加光标
3.此时可以同时删除并修改这些已经选中的变量名了。








### 类方法

```python

@classmethod
def test(cls):   # cls -->class
    print(cls)
    print(cls.)

特点

定义需要依赖装饰器
类方法中参数不是一个对象,而是类

print(cls) # <class ‘__main__.Dog’>
类方法中只可以使用类属性
类方法中不能使用普通方法

作用

因为只能访问类属性和类方法,所以可以在对象创建之前,完成一些动作和功能.

2.输入语句的使用

python里使用input内置函数接收用户的输入

input() —括号里写提示信息

3.不同进制数据的表示方式

python里的数据类型

整型(int) 浮点型(float) 复数(complex)

字符串(str) 布尔(bool) 列表(list) 字典(dict) 集合(set) 元组(tuple)

a = 0b101010101  #以0b开头的数字表示的是二进制(BIN)
a = 0o101010101  #以0o开头的数字表示的是八进制(OCT) [在python2里以0开头得数字也是八进制]
a = 101010101    #python默认使用10进制(DEC)
a = 0x2abcdef19  #以0x开头的数字表示的是十进制(HEX)

使用内置函数实现进制转换

c = 100  (在pycharm里可以使用bin(c).print快速输入代码)
print(bin(c)) #使用bin内置函数可以将数字转换为二进制
print(oct(c)) #使用oct内置函数可以将数字转换为八进制
print(hex(c)) #使用hex内置函数可以将数字转换为十六进制