python3

最新推荐文章于 2024-05-08 20:49:01 发布

炎家寶寶

最新推荐文章于 2024-05-08 20:49:01 发布

阅读量238

点赞数

本文链接：https://blog.csdn.net/Aaron_Mi/article/details/93776169

版权

列表

列表是以中括号“[]”括起来的数据类型，其中的每一个元素以逗号“,”分割，其元素可以是不同的数据类型。

特点：

1.是一个有序的

2.可以重复的序列

3.可变的数据类型

（1）列表的创建

空列表的创建

li_none=[]
type(li_none)
<class 'list'>

创建一个多值列表

li=[1,1.2,True,[1,2,3],(4,5,6),"abc"]

（2）列表的拼接

li1=[1,2,3]
li2=[4,5,6]
li1+li2
[1, 2, 3, 4, 5, 6]

（3）列表的重复

li1*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

（4）索引[]和切片[:]

索引

li=['communication','university','of','zhejiang',1949,10,1,[1,2,3],'English','Chinese']
len(li)
10
li[10]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
IndexError: list index out of range
li[0]
'communication'
li[9]
'Chinese'

切片

li[1:6]
['university', 'of', 'zhejiang', 1949, 10]
li[1:6:2]
['university', 'zhejiang', 10]

（5）列表的常见操作

1.增加

append()

在Python Console里

name=["Tom","LiLei","Hanmeimei"]
name.append("Lucy")
name
['Tom', 'LiLei', 'Hanmeimei', 'Lucy']
age=[16,17,18]
name.append(age)
name
['Tom', 'LiLei', 'Hanmeimei', 'Lucy', [16, 17, 18]]

names=[]
i=0
while True:
    name=input("请输入姓名：")
    names.append(name)
    if i==5:
        break
    i+=1
print(names)

输出：

请输入姓名：4
请输入姓名：5
请输入姓名：6
请输入姓名：4
请输入姓名：456
请输入姓名：4
[‘4’, ‘5’, ‘6’, ‘4’, ‘456’, ‘4’]

extend()

在Python Console里

name
['Tom', 'LiLei', 'Hanmeimei', 'Lucy', [16, 17, 18]]
age
[16, 17, 18]
name.extend(age)
name
['Tom', 'LiLei', 'Hanmeimei', 'Lucy', [16, 17, 18], 16, 17, 18]

insert()

在Python Console里

name=["Tom","LiLei","Hanmeimei"]
name.insert(1,"Lily")
name
['Tom', 'Lily', 'LiLei', 'Hanmeimei']

其他增加方式

name
['Tom', 'Lily', 'LiLei', 'Hanmeimei']
name[2]="Jim"
name
['Tom', 'Lily', 'Jim', 'Hanmeimei']

2.删除

pop()

name
['Tom', 'Lily', 'Jim', 'Hanmeimei']
name.pop()              #自动丢弃最后一个
'Hanmeimei'
name
['Tom', 'Lily', 'Jim']
name.pop(1)             #丢弃第1位的数据
'Lily'
name
['Tom', 'Jim']

remove()

name=["Tom","LiLei","Hanmeimei"]
name.remove("LiLei")
name
['Tom', 'Hanmeimei']

del 通用的删除函数

a=123
a
123
del a
a
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name 'a' is not defined
    
name=["Tom","LiLei","Hanmeimei"]
del name[1]
name
['Tom', 'Hanmeimei']

clear

name=["Tom","LiLei","Hanmeimei"]
del name[1]
name
['Tom', 'Hanmeimei']

3.改

name
['Tom', 'LiLei', 'Hanmeimei']
name[2]="Lucy"
name
['Tom', 'LiLei', 'Lucy']

name=["Tom","LiLei","Hanmeimei"]
name
['Tom', 'LiLei', 'Hanmeimei']
name[1:3]=["Jim","Jack"]
name
['Tom', 'Jim', 'Jack']

sr="abcd"
sr[3]=a
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name 'a' is not defined
sr[3]='a'
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'str' object does not support item assignment

4.查

元素或者切片去查

遍历

（1）元素遍历

li=["C language","Python","C++","Java"]
for i in li:
    print(i, end=" ")

输出：C language Python C++ Java

（2）索引遍历

li=["C language","Python","C++","Java"]
for i in range(len(li)):
    print(li[i], end=" ")

输出：C language Python C++ Java

（3）枚举遍历

li=["C language","Python","C++","Java"]
for i in enumerate(li):
    print(i)

(0, ‘C language’)
(1, ‘Python’)
(2, ‘C++’)
(3, ‘Java’)

li=["C language","Python","C++","Java"]
for i in enumerate(li,3):    #给一个起始位置3
    print(i)

(3, ‘C language’)
(4, ‘Python’)
(5, ‘C++’)
(6, ‘Java’)

li=[20256,23186,44,32,25105,29233,20320]
str=""
for i in li:    
str+=chr(i)
print(str)

传媒，我爱你

sr="传媒, 我爱你"
str=[]
for i in sr:
    str.append(ord(i))
print(str)

[20256, 23186, 44, 32, 25105, 29233, 20320]

sr=input("请输入一句话：")
str=[]
for i in sr:
    str.append(ord(i))
print(str)

请输入一句话：杨幂我爱你
[26472, 24130, 25105, 29233, 20320]

（6）其他操作

count()

reverse()

sort()

li=['a','a','b','c']
li.count('a')            #“a”的数量
2
li.reverse()             #倒序输出
li
['c', 'b', 'a', 'a']
li.sort()                #对列表进行排序
li
['a', 'a', 'b', 'c']
li=['3','1','d','a']
li.sort()
li
['1', '3', 'a', 'd']

元组

1.有序

2.可重复

3.不可更改

特点：

1.与列表相似

2.不可变的数据类型

3.用圆括号“()”括起来

（1）元组的创建

空元组的创建

单个元组的创建

元素后面必须加一个逗号“,”

多元组的创建

元素可以的多种数据类型

li=[]          #创建空列表           
tp=()          #创建空元组
tp=(1)         #没有逗号的是整数的创建
type(tp)
<class 'int'>
tp=(1,)        #创建单个元素的元组
type(tp)
<class 'tuple'>

a,b=("abc","def")     #压缩
a       #解压
'abc'
b
'def'

a = "abc"
b = "bcd"
c = "cde"
a, b, c
('abc', 'bcd', 'cde')
d, e, f = ('abc', 'bcd', 'cde', 'edf')   #要双引号
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: too many values to unpack (expected 3)
a, b
('abc', 'bcd')

a=1,2
a
(1, 2)

（2）元组的拼接

tp=(1,)
tp1=(2,)
tp+tp1
(1, 2)

（3）元组的重复

tp=(1,)
tp*3
(1, 1, 1)

（4）元组的查找

tp=("communication","university","of",['z','h','e'],('j','i','a','n','g'))
tp[3]
['z', 'h', 'e']
tp[3][1]              #嵌套两层 
'h'
tp=("communication","university","of",['z','h','e',['传媒','学院']],('j','i','a','n','g'))
tp[3][3][1]           #嵌套三层   
'学院'
tp[3][3][1]="大学"     #更改元组嵌套的列表嵌套的数据
tp
('communication', 'university', 'of', ['z', 'h', 'e', ['传媒', '大学']], ('j', 'i', 'a', 'n', 'g'))

tp[0]="communicate"   #元组不可以更改
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

tp[-1][0]=J
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name 'J' is not defined

tp[-1][0]='J'
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

tp=("a","b","c")
"a" in tp
True
max(tp)
'c'
min(tp)
'a'

字典

li=[“Python”,“Java”,“C++”]

li[0]=“Python”

li=[“Java”,“C++”,“Python”]

li[2]=“Python”

字典（Key:value）

基本格式：

{key1:value1,key2:value2,·····,keyn:valuen}

描述：

1.键值对之间用冒号连接(?

2.一个键值对(Key:value)构成一个元素

3.键值对之间用逗号（","）隔开

4.整个字典用花括号（"{}"）括起来

2.一个键值对

基本操作

1.字典的创建

空字典的创建

多值字典的创建

key1="name"
value1="Tom"
key2="age"
value2=18
dic={key1:value1,key2:value2}
dic
{'name': 'Tom', 'age': 18}

通过函数创建字典（强制转换）

info=dict(name="Tom",age=18,job="IT")
info
{'name': 'Tom', 'age': 18, 'job': 'IT'}

info=dict((("name","Tom"),("age",18),("job","IT")))
info
{'name': 'Tom', 'age': 18, 'job': 'IT'}

通过fromkeys()方法创建字典

2.字典的常见操作

字典的访问

字典是无序的，我们无法通过索引访问，只能通过key访问value

1.通过key访问值

key不存在，报错

info={'name':'Tom','age':18,'job':'IT'}
info["age"]
18
info["hobby"]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 'hobby'

2.使用get访问value

不确定某个key是否存在，可以使用get()方法。get()方法还可以设置默认值。

当key不存在的时候，不会抛出异常，返回None.

info
{'name': 'Tom', 'age': 18, 'job': 'IT'}
info.get("name")
'Tom'
info.get("hobbie")
           #空的

增

直接添加一个新的key-value

info
{'name': 'Tom', 'age': 18, 'job': 'IT'}
info["bobbie"]="Sing"
info
{'name': 'Tom', 'age': 18, 'job': 'IT', 'bobbie': 'Sing'}

dic.update(new_dic)

把字典new_dic的key:value更新到dic中

如果这两个字典的key:value完全不同，new_dic添加至dic中

否则，更新dic中相同key的值

info
{'name': 'Tom', 'age': 18, 'job': 'IT', 'bobbie': 'Sing'}
info1={"name":"LiLei","eat":"lunch"}
info.update(info1)
info
{'name': 'LiLei', 'age': 18, 'job': 'IT', 'bobbie': 'Sing', 'eat': 'lunch'}

删除

dict.pop(key):删除指定key:value

info={'name': 'LiLei', 'age': 18, 'job': 'IT', 'bobbie': 'Sing', 'eat': 'lunch'}
info.pop("eat")
'lunch'
info
{'name': 'LiLei', 'age': 18, 'job': 'IT', 'bobbie': 'Sing'}

dict.popitem()

info
{'name': 'LiLei', 'age': 18, 'job': 'IT', 'bobbie': 'Sing'}
info.popitem()
('bobbie', 'Sing')
info
{'name': 'LiLei', 'age': 18, 'job': 'IT'}

改

1.直接修改

info
{'name': 'LiLei', 'age': 18, 'job': 'IT'}
info["name"]="Lily"
info
{'name': 'Lily', 'age': 18, 'job': 'IT'}

2.dict.setdefault()

（1）key存在，不做改动，返回字典中key对应的value

（2）key不存在，在字典中添加新的键值对（key:value）

info
{'name': 'Lily', 'age': 18, 'job': 'IT'}
info.setdefault("age",20)
18
info
{'name': 'Lily', 'age': 18, 'job': 'IT'}
info.setdefault("hobbie","Read")
'Read'
info
{'name': 'Lily', 'age': 18, 'job': 'IT', 'hobbie': 'Read'}

查

dict.keys():查找所有的键
2.dict.value():查找所有的值
3.dict.items():查找键值对（key:value）

info
{'name': 'Lily', 'age': 18, 'job': 'IT', 'hobbie': 'Read'}
info.keys()
dict_keys(['name', 'age', 'job', 'hobbie'])
info.values()
dict_values(['Lily', 18, 'IT', 'Read'])
info.items()
dict_items([('name', 'Lily'), ('age', 18), ('job', 'IT'), ('hobbie', 'Read')])

判断是否存在键：不能用键值查找，因为键值会变，必须用键查找

'Lily' in info        #键值查找 结果为False
False
'name' in info        #键查找 结果为True
True

遍历

（1）遍历字典的key

info={'name': 'Tom', 'age': 18, 'job': 'IT'}
for key in info.keys():
    print(key,end=" ")

name age job

（2）遍历字典的value

info={'name': 'Tom', 'age': 18, 'job': 'IT'}
for value in info.values():
    print(value,end=" ")

Tom 18 IT

（3）遍历字典的所有项

info={'name': 'Tom', 'age': 18, 'job': 'IT'}
for item in info.items():
    print(item,end=" ")

(‘name’, ‘Tom’) (‘age’, 18) (‘job’, ‘IT’)

（4）遍历字典的key—value

info={'name': 'Tom', 'age': 18, 'job': 'IT'}
for key,value in info.items():
    print(key,":",value)

name : Tom
age : 18
job : IT

集合

集合是无序的，不可重复且不可更改的数据集合。

去重

关系测试，交集，差集，并集等等。

{“a”,“b”,“c”,“a”}

集合的创建

空集合（set()）

st=set()
st
set()

多元素集合的创建

a,b=("abc","def")
a
'abc'
b
'def'
st={"a","b","c","a"}
st
{'b', 'a', 'c'}            #去重操作
li=["a","b","c","a"]       #列表不能去重，强制转换为集合以后去重
st=set(li)
st
{'b', 'a', 'c'}
list(st)                   #强制转换回列表
['b', 'a', 'c']

可哈希：数据类型不可变不可哈希：数据类型可变（列表，字典）

st={1,2,3,"a","b",[1,3]}
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
st={1,2,3,"a","b"}
st
{1, 2, 3, 'b', 'a'}
st={1,2,3,"a","b",(1,3)}
st
{1, 2, 3, (1, 3), 'b', 'a'}

基本操作

查

无序，不可查找

增

st.add()

st.update()

删

st.pop()

st.remove()

st.discard()

del

st.clear()

遍历

比较（集合的基本运算）

子集

a=set("abcd")
b=set("cdef")
a
{'b', 'a', 'd', 'c'}
b
{'d', 'c', 'e', 'f'}
c=set("ab")
c
{'b', 'a'}
c<a
True
c.issubset(a)      #c是a的子集
True
c<b
False

交集

a
{'b', 'a', 'd', 'c'}
b
{'d', 'c', 'e', 'f'}
a&b                              #a和b相同的部分
{'d', 'c'}
a.intersection(b)
{'d', 'c'}

差集

a
{'b', 'a', 'd', 'c'}
b
{'d', 'c', 'e', 'f'}
a-b                              #a减去a和b相同的部分
{'b', 'a'}
a.difference(b)
{'b', 'a'}

并集

a
{'b', 'a', 'd', 'c'}
b
{'d', 'c', 'e', 'f'}
a|b                              #a和b加在一起 去重
{'b', 'a', 'd', 'c', 'e', 'f'}
a.union(b)
{'b', 'a', 'd', 'c', 'e', 'f'}

函数

数学意义上的函数

y= $2 x + 1$ , $y ∣ (x = 3) = 2 * 3 + 1$

编程意义上函数？

提高编写代码的效率

函数定义和调用

函数定义

（1）空函数

def function_name(para1,····,paran):
    pass

pass语句什么都不做，就是一个占位符。

（2）非空函数

函数通过def关键字来定义。

def后紧跟函数名称，并跟一对圆括号，以冒号结尾。接下来是函数体语句。

一般形式：

def function_name(para1,····,paran):
    '''函数说明'''
    函数体
    return 返回值

调用

Demo:

def info():
    '''打印个人信息'''
    print("Tom's age is 18, his phone number is XXXXXXXXXX")
info()
print(info.__doc__)

Tom’s age is 18, his phone number is XXXXXXXXXX
打印个人信息

def info():
    '''打印个人信息'''
    print("Tom's age is 18, his phone number is XXXXXXXXXX")
info()
print(info.__doc__)
print(help(info))

Tom’s age is 18, his phone number is XXXXXXXXXX
打印个人信息
Help on function info in module main:

info()
打印个人信息

None

函数的参数

def add(x,y):
    return x+y
print(add(3,6))

def add(x,y):
    print(x+y)
print(add(3,6))     #没有return值，就返回None

9
None

形参：在用def关键字定义函数时函数名后面括号里的变量称作为形式参数

实参：在调用函数时提供的值或者变量称作为实际参数

#这里的a和b就是形参
def add(a,b):
    return a+b

#这里的1和2是实参
add(1,2)

#这里的x和y是实参
x=2
y=3
add(x,y)

（1）位置参数

def usr_manager(name,age,job,hobbie):
    print("usr_manager_system".center(30,"*"))
    print("\tName:",name)
    print("\tAge:", age)
    print("\tJob:", job)
    print("\tHobbie:", hobbie)
    print("usr_manager_system".center(30, "*"))
usr_manager("Tom",16,"Student","Resd")

usr_manager_system
Name: Tom
Age: 16
Job: Student
Hobbie: Resd
usr_manager_system

（2）默认值参数

def usr_manager(name,age,job,hobbie="Writing"):
    #默认值参数一定要放在最后面
    print("usr_manager_system".center(30,"*")) #居中
    print("\tName:",name)
    print("\tAge:", age)
    print("\tJob:", job)
    print("\tHobbie:", hobbie)
    print("usr_manager_system".center(30, "*"))
usr_manager("Tom",16,"Student")

usr_manager_system
Name: Tom
Age: 16
Job: Student
Hobbie: Writing
usr_manager_system

（3）关键字参数

def usr_manager(name,age,job="IT",hobbie="Writing"):
    print("usr_manager_system".center(30,"*"))
    print("\tName:",name)
    print("\tAge:", age)
    print("\tJob:", job)
    print("\tHobbie:", hobbie)
    print("usr_manager_system".center(30, "*"))
usr_manager("Tom",16,job="Singer",hobbie="Drive")
#usr_manager("Tom",16,hobbie="Drive",job="Singer")互换位置也可以，会自动匹配

usr_manager_system
Name: Tom
Age: 16
Job: Singer
Hobbie: Drive
usr_manager_system

（4）不定参数

python中的不定参数，主要指两种：

*args

**kwargs

这两种主要用于函数定义，我们可以将一个不定数量的参数传递给函数。

*args的用法

可以用来传递一个非键值对的任意数量的参数列表给函数

def uncertain_para(para,*args):
    print("普通的位置参数：",para)
    print("不定参数：",args)
    print(type(args))
uncertain_para(1,2,3,4,5,6,7)

普通的位置参数： 1
不定参数： (2, 3, 4, 5, 6, 7)
<class ‘tuple’>

def uncertain_para(para1,para2,*args):
    print("普通的位置参数：",(para1,para2))
    print("不定参数：",args)
    print(type(args))
uncertain_para(1,2,3,4,5,6,7)
#把前面的值依次赋给位置参数，其他剩下的参数赋给不定参数

普通的位置参数： (1, 2)
不定参数： (3, 4, 5, 6, 7)
<class ‘tuple’>

**kwargs的用法

允许我们将不定长度的键值对，作为参数传递给函数。

def uncertain_para(para1,para2,*args,**kwargs):
    print("普通的位置参数：",(para1,para2))
    print("不定参数之非键值对参数：",args)
    print("不定参数之键值对参数：", kwargs) #不要有*传过来（不加*）
    print(type(args),type(kwargs))   #元组和字典
uncertain_para(1,2,3,4,5,"abc",a="communication",b="university")  
#把赋值的参数传给kwargs

普通的位置参数： (1, 2)
不定参数之非键值对参数： (3, 4, 5, ‘abc’)
不定参数之键值对参数： {‘a’: ‘communication’, ‘b’: ‘university’}
<class ‘tuple’> <class ‘dict’>

炎家寶寶

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python3

列表列表是以中括号“[]”括起来的数据类型，其中的每一个元素以逗号“,”分割，其元素可以是不同的数据类型。特点：1.是一个有序的2.可以重复的序列3.可变的数据类型（1）列表的创建空列表的创建li_none=[]type(li_none)<class 'list'>创建一个多值列表li=[1,1.2,True,[1,2,3],(4,5,6),"abc"]（2）...
复制链接

扫一扫