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)

[1, 2, 3, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
9
109
9

. . .

 

 

# 关于列表函数

关于列表函数?

In [5]:

 

 

l = ['a',"i nod you yj",45,55,4+4j]

l

Out[5]:

['a', 'i nod you yj', 45, 55, (4+4j)]

. . .

In [8]:

 

 

#  append 插入一个内容

?

a = [i for i in range(1,6)]

print(a)

a.append(200)

print(a)

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 200]

. . .

In [9]:

 

 

# insert :指定位置插入

# insert( index, data),插入位置是 index 前面,index :列表里字符串的位置，data ：要插入的内容

print(a)

a.insert(3,66)

print(a)

[1, 2, 3, 4, 5, 200]
[1, 2, 3, 66, 4, 5, 200]

. . .

In [11]:

 

 

# 删除

# del 删除

# pop ，从列表里拿出一个元素，即把最后一个元素取出来

print(a)

last_ele = a.pop()

print(last_ele)

print(a)

[1, 2, 3, 66, 4, 5]
5
[1, 2, 3, 66, 4]

. . .

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 直接操作的

[1, 2, 3, 660, 4]
2982625592136
[1, 2, 3, 4]
2982625592136

. . .

In [18]:

 

 

# clear:清空

print(a)

print(id(a))

a.clear()

print(a)

print(id(a))

?

# 如果不需要列表地址保存不变，则列表清空可以使用以下方法

# a = list[]

# a = []

?

[1, 2, 3, 4]
2982625592136
[]
2982625592136

. . .

In [20]:

 

 

# reverse: 反转列表内容，原列表反转

?

a = [1,2,3,4,5]

print(a)

print(id(a))

?

a.reverse()

print(a)

print(id(a))

[1, 2, 3, 4, 5]
2982626235656
[5, 4, 3, 2, 1]
2982626235656

. . .

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))

[55, 66, 77, 88, 99]
2982626235784
[55, 66, 77, 88, 99, 44, 56, 79, 87, 63]
2982626235784

. . .

In [29]:

 

 

#  count :查找列表中指定值或元素的个数

?

print(a)

a.append(88)

a.insert(77, 88)

a_len = a.count(88)

print(a_len)

?

[55, 66, 77, 88, 99, 44, 56, 79, 87, 63, 88, 88, 88]
6

. . .

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))

[5, 6, 8, 7, 5, 9]
[5, 6, 8, 7, 77, 9]
2982625992392
[5, 6, 8, 7, 77, 9]
2982625992392
********************
[5, 6, 8, 7, 77, 9]
2982625992392
[5, 6, 8, 7, 77, 9]
2982625624136
******************************
[5, 6, 8, 7, 77, 9]
2982625992392
[5, 6, 8, 7, 77, 88]
2982625624136

. . .

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)

?

2982626201736
2982626179336
1492675744
1492675744
[1, 2, 3, 4, [14, 45, 46]]
[1, 2, 3, 4, [14, 45, 46]]

. . .

 

 

#  元祖 - tuple

?

 - 元祖可以看成一个不可更改的list

# 元祖创建

?

元祖 - tuple?

• 元祖可以看成一个不可更改的list

元祖创建?

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)

<class 'tuple'>
<class 'int'>
1
<class 'int'>
1
<class 'tuple'>
(1, 2, 3, 4, 5)
<class 'tuple'>
(1, 2, 3, 4, 5)

. . .

 

 

# 元祖的特性

?

 - 是序列表，有序

 - 元祖数据值可以访问，不能修改，不能修改

 - 元祖数值可以是任意类型

 - 总之，list 所有特性，除了可以修改外，元祖都具备

 - 也就意味着， list 具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等是一模一样的

元祖的特性?

• 是序列表，有序
• 元祖数据值可以访问，不能修改，不能修改
• 元祖数值可以是任意类型
• 总之，list 所有特性，除了可以修改外，元祖都具备
• 也就意味着， list 具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等是一模一样的

In [52]:

 

 

# 索引操作

t = (1, 2, 3, 4)

print(t[2])

3

. . .

In [53]:

 

 

# 超标错误

print(t[6])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-53-778c02ad0fbb> in <module>()
      1 # 超标错误
----> 2 print(t[6])

IndexError: tuple index out of range

. . .

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)

2982624440040
2982625416968
(1, 2, 3, 4, 6, 7)
(2, 3, 4)
2982624440040
2982626418760
(1, 2, 3, 4, 6, 7)
(3, 4, 6, 7)

. . .

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

(1, 2, 3)
2982626293008
(1, 2, 3, 5, 8, 9)
2982624339648

. . .

In [63]:

 

 

# 元祖相乘

t = (1,2,3)

t = t * 3

print(t)

?

t = (1,2,3)

if 2 in t:

    print("是的")

else:

    print("没有的")

(1, 2, 3, 1, 2, 3, 1, 2, 3)
是的

. . .

In [70]:

 

 

# 元祖遍历，一般采用for

# 1.单层元祖遍历

t = (1,2,3," woshishui ")

for i in t:

    print(i,end=" ")

1 2 3  woshishui  

. . .

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)

?

(1, 2, 3, 4)
(55, 660)
('woshishui', 'wozaina', 'wozaiganma')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-82-21228346764f> in <module>()
      7     print(i)
      8 
----> 9 for k,n,m in t:
     10     print(k,"__",n,"__",m)

ValueError: too many values to unpack (expected 3)