python学习记录

火星航线

已于 2023-11-29 11:52:52 修改

阅读量1.3k

点赞数

文章标签： python 开发语言

于 2023-02-15 13:45:32 首次发布

本文链接：https://blog.csdn.net/m0_73707679/article/details/129041615

版权

基础教程笔记https://www.runoob.com/python/python-tutorial.html

一、基础知识

1.输出函数print

print默认是打印一行，结尾加换行。
end=’ '意思是末尾不换行，加空格(也可加其他内容)。

a.打印数字print()

b.打印字符串print(‘’),单引号双引号均可以

print(520)
print(98.5) 
print("liurenyu",end=' 😊 ')
print('666')

520
98.5
liurenyu 😊 666

c.打印含有运算符的表达式(输出结果)

print(3+4*2)

d.将数据输出到文件中 #注意点：print里要写 flie=fp 才能正常存入数据

fp=open('D:/text.1.txt','a+') #自动生成文件
print('hello file',file=fp)
fp.close()

2.转义字符

\ 转移功能的首字母（代码运行时起到识别作用）

补充：在单引号前加r或R可以使转义失效，不过字符串末尾不能是 \【有两个\可以】

print(r'123\t456')

123\t456

print(r'12346\\')

12346\\

a. \t 【将光标移到最接近4个空格的倍数的位置】

print('hello\tworld')  #每4个字母相当于1个\t，前面的够4个的倍数才会空4格打印后面的，否则连同余下来的凑够4格再打印后面的
print('helloo\tworld')
print('hello    word')

hello	world
helloo	world
hello    word

b.\r 【将光标移到行首，输出后面的信息。

    相当于覆盖这一行开始与后面'大小一样'的内容，将其给替换掉】

print('llll\nhh34567h\rworlds')

llll
worlds

print('hello\rw')

c. \b 【光标向前移以一格】

print('HELLO\b1')

HELLO1

d. \n 【换行】

print('\n')
print('laosna')

laosna

2.5变量的格式化输出

https://blog.csdn.net/python1639er/article/details/112325519

格式： ’ 占位符 ’ % 变量

**(1)%s 字符串
(2)%d 有符号十进制整数，%02d表示输出的整数显示2位数，不足的地方用0补全
(3)%f 浮点数，%.2f表示小数点后只显示两位
(4)%% 输出%
**

i=3
print("%4d"%i, end='*')  #得到占4位的数字，使用end=''后不会自动换行，而是接单引号''里的东西

3*

3.字符转十进制及二进制转字符

print(ord('刘')) #ord（）它以一个字符（长度为1的字符串）作为参数，返回值是对应的十进制整数
print(ord('帅'))
print(ord('汉'))
print(ord('A'))

print(chr(0b0101001000011000))
print(chr(0b0100111010111010))
print(chr(0b0111010001011100))

柳
忍
禹

3.1进制转换

https://blog.csdn.net/weixin_43353539/article/details/89444838
在这里插入图片描述

a=2
b=bin(a)  #  bin（）这些函数的返回值为字符串类型
d=bin(int(input(),10))
c=int(input(),2)  #将输入的字符串以2进制形式识别，但输出十进制
print(b)
print(oct(a))
print(c)
print(d)

3.2关于进制转换后输出——去掉进制转换符0b、0o、0x

①bin(要转换的数)[2:]
这些进制函数返回值都是字符串类型，因此可以通过从第2位开始截取，再输出

②format( int(n) , ‘#b或b’) ————让n以某一进制输出【必须先把n转成int型】
————————————————格式符#决定是否显示前置符号（没#没前置符）

a = 2
print(bin(a)[2:])

a=format(int(bin(10),2),'b')
v=10
x=format(v, 'b')
print(a)
print(type(a))
print(x)
print(type(x))

1010
<class 'str'>
1010
<class 'str'>

4.保留字(有特殊含义，so命名任何对象时不要用到他们)

import keyword
print(keyword.kwlist)

['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', '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']

5.标识符【变量、函数、类、模块及其他对象所起的名字】

规则:
只能包含字母、数字、下划线
不能以数字开头
不能用保留字
严格区分大小写

6.变量

变量由标识id【可由函数id（）得到】、类型type【可由函数type（）得到】、值value【即数据】三部分组成

name = '刘'
print(id(name))
print(type(name))
print(name)

2632192210624
<class 'str'>
刘

7.数据类型

常用：
整数类型 int
浮点类型 float

a. 整数类型int

正数、0、负数
打印输出默认为十进制

a=3
print(a,type(a))
print('十进制',8)
print('二进制',0b1000)  #二进制前加   0b
print('八进制',0o10)    #八进制前加   0o
print('十六进制',0x8)   #十六进制前加 0x

3 <class 'int'>
十进制 8
二进制 8
八进制 8
十六进制 8

b.浮点类型float

由整数和小数两部分组成
浮点数计算时，可能出现小数位数不确定的情况
【办法：导入模块decimal】
from decimal import Decimal
print(Decimal(‘数字’)+Decimal(‘数字’))
或
print(Decimal(str(变量名))+Decimal(str(变量名))

b=3.3
print(b,type(b))
n1=1.1
n2=2.1
n3=2.2
print(n1+n2)
print(n1+n3)

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
print(Decimal(str(n1))+Decimal(str(n3)))

3.3 <class 'float'>
3.2
3.3000000000000003
3.3
3.3

c.布尔类型 bool

·用来表示真或假的值
·True真，False假
·布尔值可转化为整数
True 1 False 0

f1=True
f2=False
print(type(f2))
print(f1+1)  # 1+1=2  布尔值可转成整数计算

<class 'bool'>
2

d.字符串类型 str

单引号’‘和双引号""定义的字符串必须在一行,不然会报错
三引号’‘’ ‘’'或"“” “”"定义的可分布在连续的多行

str1='我是老五， wuahahaha'
str2='''我是老六,
wuahahaha'''
print(type(str1))
print(str1)
print(str2)

<class 'str'>
我是老五， wuahahaha
我是老六,
wuahahaha

x.数据类型转换 str()函数与 int()函数、float()函数

str() 将其他数据转成字符串
int() 转成整数
float() 转成浮点数
当打印输出数据中既有str类型也有int类型时，需要将int型转换成str型【使用str()】

**补充：**变量值与其他数据一起打印时，变量名前后要写 + 或 ,起到连接作用

age=30
b= '20' ##带引号变为str型
print('今年'+str(age)+'岁')  ##  + 用来连接字符串
print(type(b))
print('今年'+b+'岁')
print(age)
print(b)

今年30岁
<class 'str'>
今年20岁
30
20

二、基础函数及相关

1.input() 输入函数

变量均为字符串类型

a.基本使用

在这里插入图片描述

name = input('我是谁')
print(name,type(name))  # input函数的变量是字符串类型

我是谁11
11 <class 'str'>

b.高级使用

a=int(input('输一个数'))
b=int(input('再输一个'))
print(a+b)

输一个数10
再输一个20
30

2.运算符

a.算术运算符

加+
减-
乘*
除/
整除//
取余%
幂运算**

print(9//4)
print(9/4)

2
2.25

print(9//-4)  #一正一负的整除公式：向下取整

-3

print(9%-4)  #公式： 余数=被除数-除数*商  9-(-4)*(-3)=-3

-3

print(2**3)  #2的3次

b.赋值运算符

有一种与C语言不同的
python支持系列解包赋值【可以这样 a,b,c=20,30,40】

a=b=c=20
a+=20
p,q,w=11,22,33
print(p,q,w)

11 22 33

a,b=11,2
a,b=b,a   #交换 
print(a,b)

2 11

c.比较运算符

结果为bool类型
变量（标识、类型、值三部分组成）
<、>、>=、==、!= 比较变量的值
is、is not 用来看 标识是否相同

a,b=10,20
print(a<b)
print('a>b吗?',a>b)
print('a的标识和b一样吗?',a is b)

True
a>b吗? False
a的标识和b一样吗? False

a=10
b=10
print(a is b)

True

x='liu'
y='liu'
print(x==y)
print(x is b)

True
False

c=[11,22]
d=[11,22]
print(c==d)
print(c is d)  ##值相同但标识不同

True
False

d.布尔运算符

布尔值之间的运算
and 相当于∩
or 相当于∪
not取反
in 包含
not int 不包含

a,b=10,20
print(a==10 and b==20)
print(not b==20)

True
False

s='liu ren yu'
print('r'in s)
print('s'in s)
print('222'not in s)

True
False

e.位运算符

将数据转成二进制进行计算
&按位与（对应数位都为1，结果数位才为1）
|按位或（对应数位都为0，结果数位才为0）
<<左移位
>>右移位

print(8&1)
print(8|1)
print(8>>1)
print(8<<1)

f.运算符优先级：先算术、位、比较、布尔

有括号，先括号里边的

3.对象的布尔值

python中一切皆对象，所有对象都有一个布尔值

布尔值为False的对象：
False、0、None、空字符串’'、
空列表[ ]或list()、空元组()或tuple()、空字典{}或dict()、空集合set()

print(bool(set()))

False

4.range()函数

用于生成一个整数序列

创建range对象的三种方式
range(stop) →创建一个0到stop(不含stop)的整数序列,步长为1
range(start,stop) →创建一个start到stop(不含stop)的整数序列,步长为1
range(start,stop,step) →创建一个start到stop(不含stop)的整数序列,步长为step

步长应该是间隔的意思

r=range(0,20,2)    ##以2为步长得到偶数
print(range(1,20,20))  ##返回值是一个迭代器对象,并不是序列
print(list(r))  ###用于查看range对象中的整数序列,   list指列表

range(1, 20, 20)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

5.len()函数

返回对象（字符、列表、元组等）长度或项目个数。
不能看整型的

print(len('300'))   ###字符长度
print(len('3000'))
print(len('liu '))  ###空格也占一位
x=[1,2,3,4,5]
print(len(x))   ###列表元素个数

6. .join()函数——合并字符串(列表转字符串)

'<需要在每个元素中间添加的字符>’.join(<目标list，且所有元素都为str类型>)

返回一个新的字符串,但原列表不会改变

b = ['j','1','k;sk','lplps']
print('***'.join(b))
print(b)

j***1***k;sk***lplps
['j', '1', 'k;sk', 'lplps']

b=['135','563']
print(''.join(b))

7. .format()函数——用于字符串格式化

主要通过字符串中的花括号{}，来识别替换字段，从而完成字符串的格式化
用法详解https://zhuanlan.zhihu.com/p/151442933

s="{} 是 {}".format('liu','帅比')  ##按花括号顺序依次匹配括号中的值
print(s)

liu 是 帅比

s='{1}是{0}'.format('c','C')   ##通过索引的方式匹配
print(s)

C是c

n='liu'           ###已知参数，利用f'{}'来进行字符串格式化
m='li'
s=f'{n} shi {m}'
print(s)

liu shi li

8.split()函数——以指定分隔符拆分字符串→转列表

可以用来实现输入以空格分隔的字符串，构建列表

lst='1 2 3'
lst2=lst.split()
str='1c2c3'
lst3=str.split('c')
print(lst2)
print(lst3)

['1', '2', '3']
['1', '2', '3']

##将输入的多行字符串放入列表中，不需要这个函数
n = int(input())
lst=[]
i=0
for i in range(0, n):
    #lst.insert(i, input())
    lst.append(input())

9.set()函数——创建一个无序不重复元素集→之后用于创建集合

set(字符串对象)

a='5555466'
print(set(a))
print(a)

{'4', '6', '5'}
5555466

import json  
a=['dddd255','xs']        #❓字典和列表、字符串关系不清晰
b=''.join(a)
c=set(b)
d=json.dumps(b)
print(c)
print(d)

{'x', 's', '2', 'd', '5'}
"dddd255xs"

stopword = ''
str = ''
for line in iter(input, stopword):
    str += line + '\n'
print(str)

10. upper()函数——转为大写字母

字符串.upper()

s='liu ren yu'
print(s.upper())

LIU REN YU

11.pass语句

Python pass 是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

在 Python 中有时候会看到一个 def 函数:

def sample(n_samples):
pass
该处的 pass 便是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。

def prin():
    pass
    print('li3')
    
print(prin())     ###打印出None是由于定义函数里没有return，默认返回None

li3
None

三、组织结构

1.顺序结构

2.选择结构

a.单分支

if 条件表达式:
条件执行体

注意事项:
a.每行if、elif或else后要跟冒号： b.判断语句下一行有自动缩进，不然报错
判断条件满足则在运行条件执行体后就跳出，不再进行下面的判断

a=10
b=20
if a!=b:
    print('你真聪明')

你真聪明

b.双分支

if 条件表达式:
条件执行体
else:
条件执行体

c.多分支

if 条件表达式:
条件执行体
elif 条件表达式:
条件执行体
else:
条件执行体

a,b,c=10,20,30 
if a<b and b<c:
    print('11')
elif a<c:       ##上面满足时，并没有判断它
    print('22')

a,b,c=10,20,30  ##判断大小
if a>b:
    t=a
else:
    t=b
if t>c:
    print(t)
else:
    print(c)

d.嵌套if

if 条件表达式:
if 内层条件表达式:
内层条件执行体1
else:
内层条件执行体2
else:
条件执行体

f.条件表达式

x if 判断条件 else y
判断条件成立则返回x，反之返回y

a=int(input('输入第一个数'))
b=int(input('输入第二个数'))
print(str(a)+'>='+str(b) if a>=b else str(a)+'<'+str(b))

3.循环结构

a.while循环

①定义条件参数初始值
②while 条件:
③ 循环体
改变条件参数

a=0
s=0
while a<101:
    s+=a
    a+=2
print(s)

b.for-in循环

for 自定义的变量 in 可迭代对象:
循环体

1.如果在循环体中不使用自定义变量,可写为 _ (其实写啥貌似都可以)

2.可迭代对象:指存储了元素的一个容器对象，且容器中的元素可以通过__iter__ ()方法或__getitem__ ()方法访问。
比如：list列表，字符串，dict字典，元组，生成器等

for x in 'liu':
    print(x)

l
i
u

for i in range(10):
    print(i)

for _ in range(3):    ###  _和任意变量都行,均是循环3次
    print('我是老大')
for x in range(3):
    print('你是老二')

x=int(input('输入3到5之间的一个整数'))

c.流程控制语句break和continue

break:满足某一条件后，退出循环结构
continue:满足某一条件后，结束当前循环，进入下一次循环

for i in range(50,101):   ##找50到100之间5的倍数
    if i%5!=0:
        break             ##可以看出break是跳出了整个循环
    else:
        print(i)

for i in range(50,101):
    if i%5!=0:
        continue
    else:
        print(i)

四、列表

类似C中的数组

列表a为空[ ]时，不能进行a[0]=1这种操作。将a定义为{ }空字典则可以。

1.创建

lst=[…] 逗号分隔
或
lst=list([…])

可以使用list()将其他类型(int不行)转为列表，s并没有变化

lst=['hello','world',10]
lst5=list(['hello','world',10])
print(f'{lst},{lst5}')
print(lst5)

['hello', 'world', 10],['hello', 'world', 10]
['hello', 'world', 10]

s='1122'
print(list(s))
print(s)

['1', '1', '2', '2']
1122

lst=[]
for i in range(3):
        lst.append(list(map(int,input().split(' '))))#二维列表的建立  以空格分隔，每次回车循环一次
print(lst[1][1])

1.5eval()—— 键盘直接输入列表问题

用input输入列表的方法详解

lst = eval(input())

lst = eval(input('输入一个列表：'))   # 按列表格式输入才行
print(lst)
print(type(lst))

输入一个列表：1,2,3,4
(1, 2, 3, 4)
<class 'tuple'>

2.index()函数——查询指定元素的索引

①列表对象.index(列表中的某一元素)
②列表对象.index(列表某一元素，开始查询的位置，停止且不查询的位置)

列表索引从0开始，
含有相同元素时，index只显示第一个查询到的索引

lst=['liu',11,22,'liu']
print(lst.index('liu'))      
print(lst.index('liu',1,4))  ##从索引[1，4）区间查询liu对应的索引
print(index_lst[1])

0
3



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

NameError                                 Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_23980\1401603543.py in <module>
      2 print(lst.index('liu'))
      3 print(lst.index('liu',1,4))  ##从索引[1，4）区间查询liu对应的索引
----> 4 print(index_lst[1])


NameError: name 'index_lst' is not defined

3.获取列表指定的元素

列表对象[索引]

lst=['liu',11,22,'liu']
print(lst[0])

liu

4.切片操作——获取多个元素

列表名[start:stop:step]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rBLC6lDw-1676438436170)(attachment:IMG_20230207_124837.jpg)]

lst=[10,2,3,4,5,6]
lst2=lst[1:3:2]
lst3=lst[:0:-2]  ##step为负，默认从最后一个元素开始
print(lst2)
print(lst3)
print(lst[0:1])

[2]
[6, 4, 2]
[10]

5.判断元素是否存在

用in和not in布尔运算符

lst=[10,2,3,4,5,6]
print(10 in lst)

True

6.添加

1)列表名.append()：可以向列表的末尾增加数据

2)列表名.insert(索引x，新元素)：可以在原列表索引为x的数据前插入新元素

3)列表名.extend(列表名)：可以把其他列表中的完整内容追加到当前列表的末尾
也可以直接lst3=lst+lst2

4）lst[start:stop]=lst2[start2:stop2]: 切片插入,相当于把[start,stop)的元素替换成lst2的

lst=[10,2,3,4,5,6]
lst.insert(1,20)
print(lst.index(2))

lst=[10,2,3,4,5,6]
lst2=[2023,521]
lst[1:3]=lst2[0:1]   ##从lst索引为1前切
print(lst)
print(lst.index(2023))

[10, 2023, 4, 5, 6]
1

lst=[10,2,3,4,5,6]
lst2=[2023,521]
lst2.extend(lst)
print(lst2)

[2023, 521, 10, 2, 3, 4, 5, 6]

6.5将多个一维列表合成多维列表

https://blog.csdn.net/qq_44324181/article/details/109686785
里边有一个使用zip的，还没看

lst=[10,2,3,4,5,6]
lst2=[2023,521]
lst3=[lst]+[lst2]
print(lst3)

[[10, 2, 3, 4, 5, 6], [2023, 521]]

7.删除

1)列表名.remove(数据名)：可以从列表中删除指定的数据

重复元素只删第一个

2)列表名.pop(n)：可以从列表中删除第n-1个数据，在默认情况下删除列表中最后一个数据

3)切片操作，用空列表[ ]替换某一片段即可

4)列表名.clear()：可以清空列表

5)del 列表名[n]：删除列表中第n-1个数据

lst=[10,2,3,4,5,6]
print(id(lst))
del lst[0]
print(lst)
print(id(lst))  ##标识并不会发生改变

2687216401408
[2, 3, 4, 5, 6]
2687216401408

8.排序

1)列表名.sort(): 升序排序

2)列表名.sort(reverse=True): 降序排序

内置函数sorted(列表名)：升序排列产生新的列表对象，但原列表不改变

内置函数sorted(列表名,reverse=True)：降序排列产生新的列表对象，但原列表不改变(reverse指反向)

3)列表名.reverse()：逆序排序

lst=[10,2,3,4,5,6]
lst.sort()
print(lst)

[2, 3, 4, 5, 6, 10]

lst=[10,2,3,4,5,6]
print(sorted(lst,reverse=True))
print(lst)     ##原列表次序并没有改变

[10, 6, 5, 4, 3, 2]
[10, 2, 3, 4, 5, 6]

lst=[10,2,3,4,5,6]
lst.sort(reverse=True)
print(lst)

[10, 6, 5, 4, 3, 2]

lst=[10,2,3,4,5,6]
lst.reverse()
print(lst)

[6, 5, 4, 3, 2, 10]

9.列表生成式

lst=[i*2 for i in range(1,10)]
print(lst)

[2, 4, 6, 8, 10, 12, 14, 16, 18]

在这里插入图片描述

应用：将列表中的字符串转化为数字

lst=[int(x)for x in lst]

lst=[]
for i in range(5):
    lst.append(input())
lst=[int(x)for x in lst]
#lst = list(map(int, lst))  也可以使用map（）函数
print(lst)

2
3
4
6
5
[2, 3, 4, 6, 5]

10.关于列表复制

详细讲解https://blog.csdn.net/qq_38828370/article/details/119826285

将列表a直接等于b时，在改变b时，a会同时改变
要想让a不受影响，需要使用深度拷贝

import copy
b = copy.deepcopy(a) # copy模块中的deepcopy函数

l=[[0],1,2,3]
m=l.copy()
m[0][0]=1
print(l)   ## 列表里含列表时，改变m的里边列表的数，n也变【其他情况则正常，原列表不会随m改变】

[[1], 1, 2, 3]

import copy
l=[[0],1,2,3]
m=copy.deepcopy(l)  #使用copy模块里的深度copy则不影响原列表
m[0][0]=1
print(l)

[[0], 1, 2, 3]

11.列表去重问题——消掉重复元素

https://www.py.cn/faq/python/22386.html#:~:text=python中,orted函数。

12.列表转字典

详细多方法https://blog.csdn.net/Strive_0902/article/details/119856186

使用enumerate()
①列表元素下标index作key：
dict(enumerate(列表名))
②index作value：
遍历依次写进字典

    #index做为key
    l1=['a','b','c','d']
    print(dict(enumerate(l1)))
    #{0: 'a', 1: 'b', 2: 'c', 3: 'd'}
 
    
    #index作为value，列表元素作为key
    d={}
    for index,val in enumerate(l1):
        d[val]=index
    print(d)
    #{'a': 0, 'b': 1, 'c': 2, 'd': 3}

{0: 'a', 1: 'b', 2: 'c', 3: 'd'}
{'a': 0, 'b': 1, 'c': 2, 'd': 3}

l=[1,2,3]
a=max(l[0],l[2])
print(a)

五、字典

由键值对（键相当于索引，值是数据）组成
键不允许重复，值可以

1.创建

每个键值对之间用，隔开

a.使用花括号{}

值可以取任意数据类型，但键只能使用字符串、数字或元组【不能使用列表】。

b.内置函数dict()
等号赋值的形式(dict里键不能用数字)

s = {2:20,'li':10}
print(s)

{2: 20, 'li': 10}

s = dict(a='liu',age=20)
print(s)

{'a': 'liu', 'age': 20}

2.元素获取

a.使用[ ] ##字典里没此键时会报错
字典名[ 键]

b.使用get() ##查找字典里没有此键时，返回None
字典名.get(键)

s = {'liu':20,'li':10}
print(s['liu'])
print(s.get('liu'))
print(s.get('l'))

20
20
None

3.增删改

增和改
字典名[key]=value 如果key不存在，会增加键值对，如果key存在，会修改键值对

删
del 字典名[key]
字典名.pop(key)

s = {'liu':20,'li':10}
s['xiao']=25
print(s)

{'liu': 20, 'li': 10, 'xiao': 25}

s = {'liu':20,'li':10}
del s['liu']
print(s)

{'li': 10}

s = {'liu':20,'li':10}
s.pop('liu')
print(s)

{'li': 10}

4.获取视图——获取所有key或所有value或所有键值对

a.获取所有key键

字典名.keys()

scores = {'张三':100,'李四':80,'王五':60}
jian = scores.keys()
print(jian)
print(list(jian))

dict_keys(['张三', '李四', '王五'])
['张三', '李四', '王五']

b.获取所有value值

字典名.values()

scores = {'张三':100,'李四':80,'王五':60}
zhi = scores.values()
print(zhi)
print(list(zhi))

dict_values([100, 80, 60])
[100, 80, 60]

a.获取所有键值对

字典名.items()

scores = {'张三':100,'李四':80,'王五':60}
all = scores.items()
print(all)
print(list(all))

dict_items([('张三', 100), ('李四', 80), ('王五', 60)])
[('张三', 100), ('李四', 80), ('王五', 60)]

5.元素遍历

for item in 字典名：
print(item) *****item是键

scores = {'张三':100,'李四':80,'王五':60}
for keys in scores:
    print(keys)
    print(type(keys))
    print(scores[keys])

张三
<class 'str'>
100
李四
<class 'str'>
80
王五
<class 'str'>
60

6.字典生成式

同列表生成式

利用内置函数zip（）
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

字典名={键：值 for 键,值 in zip(作为键的列表名k,作为值的列表名vl)}

在这里插入图片描述

k=['lala','faf','sx']
vl=[10,20,30]
d={keys:values for keys,values in zip(k,vl)}
print(d)
print(list(zip(k,vl)))

{'lala': 10, 'faf': 20, 'sx': 30}
[('lala', 10), ('faf', 20), ('sx', 30)]

不可变序列(即不能在不改变本身地址(标识)的情况下直接增删改)

六.元组

元组是一种序列，它支持序列的基本操作，包括索引、切片、序列加、序列乘、in、len()、max()、min()。
元组不可修改，指的是元组中每个元素的指向（地址）永远不变。

元组的元素不能被修改，但是元组的元素的元素如果是可被修改的，那元组的元素的元素就可以被修改。
如对(‘tt’,[1,2,3],1),可以对其中的列表里的数据进行增删,但不能改变列表的标识

1.创建

a.使用()
b.内置函数tuple(元组)

t = ('liu','x',11)   #多个元素括号可以省,  只含一个元素时除了加()还要在元素后加逗号 ,
t1=('liu',)
s2=('li')  #不含逗号时,类型为str

print(t)
print(type(t))

print(t1)
print(type(t1))

print(s2)
print(type(s2))

('liu', 'x', 11)
<class 'tuple'>
('liu',)
<class 'tuple'>
li
<class 'str'>

t = tuple(('liu','x',11))
print(t)

('liu', 'x', 11)

2.遍历

t = ('liu','x',11)
for i in t:
    print(i)

liu
x
11

3.查询

看元素的索引:元组名.index(数据名)

看元素数据:元组名[ ]

t = ('liu',[1,2,10],10)
print(id(t[1]))
t[1].append(3)           #对元素是可变序列的能进行增删,但不能使该元素的标识（地址）发生变化
t[1][0]=4
print(id(t[1]))

2632193638848
2632193638848

七、集合

集合与字典相似，但没有键，且元素不能有重复,且无序

1.创建

a.直接{元素1，元素2}

b.内置函数set()
定义空集合直接s = set()

a={1,2,2,3}  #会进行“去重”
print(a)
b=set([1,2,3])
c=set({1,2,7})
d=set((1,2,8))  #表明集合元素无序
print(b)
print(c)
print(d)

{1, 2, 3}
{1, 2, 3}
{1, 2, 7}
{8, 1, 2}

#定义空集合用set（）
s = set()
print(s)
print(type(s))

set()
<class 'set'>

八、自定义函数

1.定义

def 函数名（）：
函数封装的代码

1）函数名称的命名可以由字母、下划线组成，不能以数字开头，不能与关键字重名
2)开头空两行，方便分辨

def a():
    a = 1
    return a
def b():
    c=a()+1
    return c
s = b()

九、类和方法

https://blog.csdn.net/wander_ing/article/details/105964250

类和函数的差异
https://zhuanlan.zhihu.com/p/108418193

https://blog.csdn.net/xhaimail/article/details/104795752

# -.- coding:utf-8 -.-
# __author__ = 'zhengtong'
 
class Person:         # 没有object
    name = "zhengtong"
class Animal(object):  # 写了object ，现在的版本没有差别了
    name = "chonghong" 
if __name__ == "__main__":
    x = Person()
    print ('Person', dir(x))
 
    y = Animal()
    print ("Animal", dir(y))

Person ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
Animal ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']