python 内置函数
python 内置函数
# 传值和传址的区别
# 对于简单的数值，采用传值操作，即在函数内对参数的操作不影响函数外的变量(生成一个新的内容不影响原内容)
# 对于复杂变量，采用传址操作，此时函数内参数和外部变量式使用的同意内容，任何一方对此内容的更改都影响另一变量或参数的使用
def a(n):
n[2] = 300
print(n)
return None
def b(n):
n += 100
print(n)
return None
an = [1,2,3,4,5,6]
bn = 9
print(an)
a(an)
print(an)
print(bn)
b(bn)
print(bn)
. . .
# 关于列表函数
关于列表函数¶
In [5]:
l = ['a',"i nod you yj",45,55,4+4j]
l
Out[5]:
. . .
In [8]:
# append 插入一个内容
a = [i for i in range(1,6)]
print(a)
a.append(200)
print(a)
. . .
In [9]:
# insert :指定位置插入
# insert( index, data),插入位置是 index 前面,index :列表里字符串的位置，data ：要插入的内容
print(a)
a.insert(3,66)
print(a)
. . .
In [11]:
# 删除
# del 删除
# pop ，从列表里拿出一个元素，即把最后一个元素取出来
print(a)
last_ele = a.pop()
print(last_ele)
print(a)
. . .
In [16]:
# remove ：在列表中删除指定的元素
# 如果被删除的值没在 list 中，则报错
# 即，删除的 list 指定值的操作应该使用 try。。。excepty语句，或先执行再判断
# if x in list:
# list.remove(x)
a.insert(3,660)
print(a)
print(id(a))
a.remove(660)
print(a)
print(id(a))
# 两个 id 值是一样的，说明，remove 操作是在原 list 直接操作的
. . .
In [18]:
# clear:清空
print(a)
print(id(a))
a.clear()
print(a)
print(id(a))
# 如果不需要列表地址保存不变，则列表清空可以使用以下方法
# a = list[]
# a = []
. . .
In [20]:
# reverse: 反转列表内容，原列表反转
a = [1,2,3,4,5]
print(a)
print(id(a))
a.reverse()
print(a)
print(id(a))
. . .
In [21]:
# extend :扩展列表，两个列表，把一个直接拼接到另一个上去
a = [55,66,77,88,99]
b = [44,56,79,87,63]
print(a)
print(id(a))
a. extend(b)
print(a)
print(id(a))
. . .
In [29]:
# count :查找列表中指定值或元素的个数
print(a)
a.append(88)
a.insert(77, 88)
a_len = a.count(88)
print(a_len)
. . .
In [34]:
# copy :拷贝，此函数为浅拷贝
# 列表类型变量赋值示例
a = [5,6,8,7,5,9]
print(a)
# lisr 类型，简单的赋值操作，是传址操作（传地址）
b = a
b[4] = 77
print(a)
print(id(a))
print(b)
print(id(b))
print("*" * 20)
# 为了解决以上问题， list 赋值需要采用 copy 函数
b = a.copy()
print(a)
print(id(a))
print(b)
print(id(b))
print("*" * 30)
b[5] = 88
print(a)
print(id(a))
print(b)
print(id(b))
. . .
In [45]:
# 深考呗与浅拷贝区别
# 出现下列问题的原因是，copy 函数是一个浅拷贝函数，即只拷贝一层内容
# 深拷贝需要使用特定工具
a = [1, 2, 3, 4, [14, 45, 46]]
b = a.copy()
print(id(a))
print(id(b))
print(id(a[3]))
print(id(b[3]))
a[3] == a[2] == 666
print(a)
print(b)
. . .
In [49]:
# 创建空元祖
t = ()
print(type(t))
# 创建一个只有一个值的元祖
t = (1)
print(type(t))
print(t)
t = 1
print(type(t))
print(t)
# 创建多个值的元祖
t = (1, 2, 3, 4, 5)
print(type(t))
print(t)
l = [1, 2, 3, 4, 5]
t = tuple(l)
print(type(t))
print(t)
. . .
# 元祖的特性
- 是序列表，有序
- 元祖数据值可以访问，不能修改，不能修改
- 元祖数值可以是任意类型
- 总之，list 所有特性，除了可以修改外，元祖都具备
- 也就意味着， list 具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等是一模一样的
元祖的特性¶
- 是序列表，有序
- 元祖数据值可以访问，不能修改，不能修改
- 元祖数值可以是任意类型
- 总之，list 所有特性，除了可以修改外，元祖都具备
- 也就意味着， list 具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等是一模一样的
In [52]:
# 索引操作
t = (1, 2, 3, 4)
print(t[2])
. . .
In [53]:
# 超标错误
print(t[6])
. . .
In [57]:
t = (1,2,3,4,6,7)
t1 = t[1:4]
print(id(t))
print(id(t1))
print(t)
print(t1)
# 切片可以超标
t2 = t[2:50]
print(id(t))
print(id(t2))
print(t)
print(t2)
. . .
In [59]:
# 序列相加
t1 = (1,2,3)
t2 = (5,8,9)
# 传址操作
print(t1)
print(id(t1))
t1 += t2
print(t1)
print(id(t2))
# 以上操作，类似于
t1 = (1,2,3)
t1 = (2,3,4)
# tuple 的不可修改，指的是内容不可修改
# 修改 tuple 内容会导致报错
t1[1] = 100
. . .
In [63]:
# 元祖相乘
t = (1,2,3)
t = t * 3
print(t)
t = (1,2,3)
if 2 in t:
print("是的")
else:
print("没有的")
. . .
In [70]:
# 元祖遍历，一般采用for
# 1.单层元祖遍历
t = (1,2,3," woshishui ")
for i in t:
print(i,end=" ")
. . .
In [82]:
# 2.双层元祖的遍历
t = ((1,2,3,4), (55,660), ("woshishui","wozaina","wozaiganma"))
# 对以上元祖的遍历，可以如下
# 1.
for i in t:
print(i)
for k,n,m in t:
print(k,"__",n,"__",m)
版权声明：本文为yuanjian6原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。