Python 入门学习详细知识点+典型例题/自学笔记（二）

字母符号数字

已于 2022-08-02 18:16:11 修改

阅读量698

点赞数 2

分类专栏： Python 文章标签：学习 python 哈希算法

于 2022-07-29 18:03:43 首次发布

本文链接：https://blog.csdn.net/m0_64600894/article/details/125954049

版权

Python 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

上接：Python 入门学习详细知识点/自学笔记（一）_字母符号数字的博客-CSDN博客

一.序列（列表，元组，字符串）

共同点：

1.都可以通过索引获取每一一个元素

2.第一个元素索引值都是0

3.都可以通过切片方法获取一个范围

4.都有很多共同的运算符

is / is not 检测对象的id值是否相等

in / not in 检测是否包含

del 删除一个或多个指定对象

x=[1,2,3]        删除下x,y
y=[4,5,6]
del x,y

x=[1,2,3,4,5,6]            
del x[1:4]                删除0-4
x
[1, 5, 6]


y=[1,2,3,4,5]
  
y[1:4]=[]                    
y
[1, 5]


x=[1,2,3,4,5]
del x[::2]                 
x 
[2, 4]


x=[1,2,3,4,5] 
x.clear ()
x 
[]

y=[1,2,3,4,5]
del y[:]
y
[]

二.函数

list () 将字符串（元组）变为列表

tuple() 将字符串（列表）变为元组

str() 将元组（列表）变为字符串

s="你要好好学习"
list(s)
['你', '要', '好', '好', '学', '习']
tuple(s)
('你', '要', '好', '好', '学', '习')

min() 最小值

max() 最大值

min(1,2,3,4,5,6)
1
max(1,2,3,4,5,6)
6

len() 求长度

sum() 求和

s=[1,0,0,5,6]
sum(s)
12
sum(s,start=100)
112

sorted() 返回排序全新列表

t=["pen","Book","fishc","Apple","Banana"]
sorted(t)
['Apple', 'Banana', 'Book', 'fishc', 'pen']

sorted(t,key=len)
['pen', 'Book', 'fishc', 'Apple', 'Banana']

t.sort(key=len)
t
['pen', 'Book', 'fishc', 'Apple', 'Banana']

sorted("python")
['h', 'n', 'o', 'p', 't', 'y']

reversed() 排序后翻转

s=[1,2,5,8,0]
list(reversed(s))
[0, 8, 5, 2, 1]
s.reverse ()
s
[0, 8, 5, 2, 1]

sorted(s,reversed=True)

list(reversed("python"))
['n', 'o', 'h', 't', 'y', 'p']


list(reversed((1,2,5,9,3)))
[3, 9, 5, 2, 1]

list(reversed(range(0,10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

all() 判断所有值是否都为真

any() 判断是否存在某个元素值为真

x=[1,2,0]
y=[2,3,4]
all(x)
False
any(x)
True
all(y)
True
any(y)
True

enumerate() 从0开始的序号共同构成一个二元列表

seasons=["春","夏","秋","冬"]
enumerate(seasons)
<enumerate object at 0x00000163FEABFA80>
list(enumerate(seasons))
[(0, '春'), (1, '夏'), (2, '秋'), (3, '冬')]

zip 依次组合为元组

x=[1,2,3]
y=[4,5,6]
z=zip(x,y)
list(z)
[(1, 4), (2, 5), (3, 6)]

import itertools
z="python"
zipped=itertools.zip_longest (x,y,z)
list(zipped)
[(1, 4, 'p'), (2, 5, 'y'), (3, 6, 't'), (None, None, 'h'), (None, None, 'o'), (None, None, 'n')]

map( )

m=map(ord,"python")            字符转换为编码值
list(m)
[112, 121, 116, 104, 111, 110]

m=map(pow,[2,3,10],[5,2,3])
list(m)
[32, 9, 1000]

filter() 返回计算结果为真的值（过滤器）

list(filter(str.islower ,"PYthon"))                    islower为返回小写字母
['t', 'h', 'o', 'n']

一个迭代器（一次性的）肯定是一个可迭代对象（可重复使用）

三.字典（映射关系的直接类型）

在映射类型数据的获取上，字典的效率要远远快于列表

y={"吕布":"口口布","关羽":"关习习"}
type(y)   
<class 'dict'>
y["吕布"]
'口口布'



y["刘备"]="刘baby"                添加
   
y
   
{'吕布': '口口布', '关羽': '关习习', '刘备': '刘baby'}

3.1创建字典方法：

a={'吕布': '口口布', '关羽': '关习习', '刘备': '刘baby'}

2.使用dict()函数

b=dict(吕布="口口布",关羽="关习习",刘备="刘baby")

3.使用列表作为参数

c=dict([("吕布","口口布"),("关羽","关习习"),("刘备","刘baby")])

4.传参法

d=dict({"吕布": "口口布", "关羽": "关习习", "刘备": "刘baby"})

5.混合法

e=dict({"吕布": "口口布", "关羽": "关习习"},刘备="刘baby")

6.zip()法

f=dict(zip(["吕布","关羽","刘备"],["口口布","关习习","刘baby"]))

3.2增

在字典中键不能重复，否则会被新的覆盖

fromkeys(iterable[,values]) 方法

创建一个所有键的值都相同的字典

d=dict.fromkeys ("python",250)
d
{'p': 250, 'y': 250, 't': 250, 'h': 250, 'o': 250, 'n': 250}

修改键的值

d['p']=80
d
{'p': 80, 'y': 250, 't': 250, 'h': 250, 'o': 250, 'n': 250}

增加

d['s']=100
d
{'p': 80, 'y': 250, 't': 250, 'h': 250, 'o': 250, 'n': 250, 's': 100}

3.3删

pop(key[,default]) 方法

d.pop('s')
100
d
{'p': 80, 'y': 250, 't': 250, 'h': 250, 'o': 250, 'n': 250}

若不存在：

d.pop("狗","没有")
'没有'

popitem() 删除最后一个加入的键值

d.popitem ()
('n', 250)
d
{'p': 80, 'y': 250, 't': 250, 'h': 250, 'o': 250}

del () 删除一个指定的字典元素或者删除整个字典

del d['y']
d
{'p': 80, 't': 250, 'h': 250, 'o': 250}

del d
d

Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    d
NameError: name 'd' is not defined. Did you mean: 'id'?

clear () 清空字典中的内容

{'p': 250, 'y': 250, 't': 250, 'h': 250, 'o': 250, 'n': 250}
d.clear()
d
{}

3.4 改

d=dict.fromkeys("python")
d
{'p': None, 'y': None, 't': None, 'h': None, 'o': None, 'n': None}
d['t']=100
d
{'p': None, 'y': None, 't': 100, 'h': None, 'o': None, 'n': None}

update（）修改多个键值对

d.update({'t':150,'h':250})
d
{'p': None, 'y': None, 't': 150, 'h': 250, 'o': None, 'n': None}
d.update (p='50',o='300')
d
{'p': '50', 'y': None, 't': 150, 'h': 250, 'o': '300', 'n': None}

3.5 查

给一个键直接返回值

d['p']
'50'

get(key[,default]) 方法找不到时候可以返回值

d.get ('P',"这里没有大写的P")
'这里没有大写的P'

setdefault(key[,default]) 查找时若不存在可以赋新值

d.setdefault ('P',"code")
'code'
d
{'p': '50', 'y': None, 't': 150, 'h': 250, 'o': '300', 'n': None, 'P': 'code'}

3.6

items( ) keys( ) values( ) 分别获取字典的键值对，键，值三者的视图对象

d={'p': '50', 'y': None, 't': 150, 'h': 250, 'o': '300', 'n': None, 'P': 'code'}
d
{'p': '50', 'y': None, 't': 150, 'h': 250, 'o': '300', 'n': None, 'P': 'code'}
keys=d.keys()
values=d.values()
items=d.items ()
items
dict_items([('p', '50'), ('y', None), ('t', 150), ('h', 250), ('o', '300'), ('n', None), ('P', 'code')])
keys
dict_keys(['p', 'y', 't', 'h', 'o', 'n', 'P'])                键
values
dict_values(['50', None, 150, 250, '300', None, 'code'])            值
d.pop ('P')                    删除P后视图也跟着变化
'code'
d
{'p': '50', 'y': None, 't': 150, 'h': 250, 'o': '300', 'n': None}
items
dict_items([('p', '50'), ('y', None), ('t', 150), ('h', 250), ('o', '300'), ('n', None)])
keys
dict_keys(['p', 'y', 't', 'h', 'o', 'n'])
values
dict_values(['50', None, 150, 250, '300', None])

copy( ) 浅拷贝

len( ) 求长度

in /not in

len(d)                求d的长度
6

'p'in d                判断p是否在d中
True

'p'not in d             
False

list() 字典转换为列表

list(d)
['p', 'y', 't', 'h', 'o', 'n']

list(d.values())
['50', None, 150, 250, '300', None]

3.7嵌套

d={"吕布":{"语文":60,"数学":70,"英语":80},"关羽":{"语文":80,"数学":90,"英语":100}}
d
{'吕布': {'语文': 60, '数学': 70, '英语': 80}, '关羽': {'语文': 80, '数学': 90, '英语': 100}}
d["吕布"]["数学"]
70

3.8 字典推导式

键和值调换

d={'f':70,'i':105,'s':115,'h':104,'c':67}
b={v:k for k,v in d.items ()}
b
{70: 'f', 105: 'i', 115: 's', 104: 'h', 67: 'c'}

条件判断后筛选

c={v:k for k,v in d.items () if v>100}
c
{105: 'i', 115: 's', 104: 'h'}

求编码值

d={x:ord(x) for x in "Python"}
d
{'P': 80, 'y': 121, 't': 116, 'h': 104, 'o': 111, 'n': 110}

四 .集合（唯一性）

创建一个集合

{"python","set"}
{'python', 'set'}

使用集合推导式创建

{s for s in "python"}
{'o', 't', 'n', 'p', 'y', 'h'}            体现了随机（无序）性

使用类型构造器构造

set("python")
{'o', 't', 'n', 'p', 'y', 'h'}

唯一性

set([1,1,2,3,5])
{1, 2, 3, 5}

判断是否重复

set([1,1,2,3,5])
{1, 2, 3, 5}
s=[1,1,2,3,5]
len(s)==len(set(s))
False

isdistroyed 检测两个集合毫不相干

s=set("python")
s
{'o', 't', 'n', 'p', 'y', 'h'}
s.isdisjoint (set("home"))                有o共同
False
s.isdisjoint (set("java"))
True

issubset 判断是否是另外一个集合的子集

s.issubset("python.com.cn")
True

issuperset 判断是否为另外集合的超集

s.issuperset("python")
True

union 并集

s.union([1,2,3])
{1, 2, 3, 'o', 'n', 'p', 'y', 't', 'h'}

intersection 交集

s.intersection("pyt")
{'y', 't', 'p'}

difference 差集

s.difference("pyth")
{'o', 'n'}

symmetric_difference 对称差集

s.symmetric_difference ("java")
{'o', 'n', 'v', 'h', 'a', 'p', 'y', 't', 'j'}

检测子集

s<=set("python")
True

检测真子集

s<set("python")
False

> />= 检测超集或者真超集

| 并集

s|{1,2,3}|set("python")
{1, 2, 3, 'o', 'n', 't', 'p', 'y', 'h'}

& 交集

- 差集

^ 对称差集

2.不可变的集合 frozenset ( )

t=frozenset("python")
t
frozenset({'h', 'p', 't', 'y', 'n', 'o'})

update(*others) 使用others参数指定的值来更新集合

s=set("python")
s
{'h', 'p', 't', 'y', 'n', 'o'}
s.update ([1,1],"23")                插入1，1，2，3
s
{'h', 'p', 1, '2', '3', 't', 'y', 'n', 'o'}

插入 add( )

s.add("250")
s
{'h', 'p', 1, '2', '3', '250', 't', 'y', 'n', 'o'}

删除元素 remove( elem) 若不存在会抛出异常 discard( elem) 静默处理

随机弹出一个元素 pop()

清空集合 clear( )

3.可哈希（可以变的对象）

可哈希才能作为字典的键

hash（）获取一个哈希值

下接：

Python 入门学习详细知识点+典型例题 /自学笔记（三）_字母符号数字的博客-CSDN博客