塞进裤子ヾ(≧O≦)〃嗷~

0%

python学习

list

list转string

1
2
b = ['B','#']
strb = "".join(b)#b还是list

int转lsit

1
2
3
4
5
6
x = 12258
xlist = [int(i) for i in str(x)]

xlist = list(map(int,str(x)))#若无外面的list,则返回<map object

xlist #[1, 2, 2, 5, 8]

list做函数参数

list做函数参数会改变原lsit 的值,将某个列表(比如这里的list)作为参数传入某个函数 。其传递的是list所在的真实地址。所有修改也是对list直接的修改。

1
2
3
4
5
6
7
8
9
def xx():
x=[1,2,3]
print(x) #123
usex(x)
print(x)#1234
def usex(x):
x.append(4)

xx()

可变对象

list和dict是可变对象

其对象的内容是可以变化的。当对象的内容发生变化时,变量的对象引用是不会变化的。换句话说,做参数时传的是地址

传可变对象进去,就是传引用,比如 list
传不可变对象进去,就是传值,比如 string
注意:对可变对象进行赋值,会产生新对象,而不是修改旧对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def dd(x):
x=[1,2] #对list赋值,不改变原list
def dd2(x):
x.append(33)
def dd3(x):
x[0]=100 #对list[index]赋值,改变原list
x = [22,44]
dd(x)
print(x) #[22,44]
dd2(x)
print(x)#[22,44,33]
dd3(x)
print(x)#[100, 44, 33]
============================
a=[3]
def tt(a):
a[0]=6
tt(a)
print(a) #[6]
===
a=3
def tt(a):
a=6 #若未进行赋值,可当作全局变量
tt(a)
print(a) #3
====
a=[3]
def tt():
a[0]=111
tt()
print(a) #[111]
==============================
a=[1,2,3,4]
b=[]
b.append(a)
a.pop()
print(b) #[[1,2,3]] #a改变b也会 改变
=====
a=[1,2,3,4]
b=[]
b.append(a.copy())#浅拷贝
a.pop()
b #[1,2,3,4]

浅拷贝深拷贝

https://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html

gloabl

https://www.cnblogs.com/summer-cool/p/3884595.html

string

删除

replace

1
2
3
x = "abcdab"
x= x.replace('a','',1) #最后一个参数指定替换的次数
print(x)

转成list remove

装饰器

1
2
3
4
5
6
7
8
9
首先,明白python中万物皆对象,注意两种调用函数的方法

def cal(x, y):
result = x + y
return result
output = cal(1,2)
或者
calculate = cal
output = calculate(1,2)
1
2
3
4
5
6
7
8
9
10

def uselogging(func):
print("{} is running".format(func.__name__))

def bar():
print("i am bar")

uselogging(bar)#只调用了uselogging函数,而未调用bar函数
-----
bar is running
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def uselogging(func):
def wrapper(*args, **kwargs):
print("{} is running".format(func.__name__))
return func(*args, **kwargs) #注意func后面有(),wrapper执行func()

return wrapper #uselogging 返回wrapper对象

def bar():
print("i am bar")

bar2 = uselogging(bar)
#uselogging 返回wrapper对象给bar2,这个bar2可以是任意名字
bar2()
#bar2()即wrapper(),而wrapper()做的是print并执行bar()
-----
bar is running
i am bar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
为减少语句,现在对上一程序加入@语法糖
def uselogging(func):

def wrapper(*args, **kwargs):
print("{} is running".format(func.__name__))
return func(*args, **kwargs) #wrapper执行func()

return wrapper #uselogging 返回wrapper对象

@uselogging #@是装饰器语法糖,可以省去bar=uselogging(bar)这一句话
def bar():
print("i am bar")

bar()
-----
bar is running
i am bar

@classmethod

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class A(object):
bar = 1

def func1(self):
print('foo')

@classmethod
def func2(cls): #第一个参数指的是类A本身。名字可任意,这里是cls
print('func2')
print(cls.bar)
cls().func1() # 调用 foo 方法

A.func2() # 不需要实例化
-----
func2
1
foo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Book(object):
def __init__(self, title1):
self.title = title1

@classmethod
def create(cls, title2):
book = cls(title1=title2)#相当于Book(title1=title2)
return book

book1 = Book("python") #普通的实例化方法
book2 = Book.create("python and django")
print(book1.title)
print(book2.title)
-----
python
python and django

@staticmethod

1
2
3
4
5
6
7
8
class C(object):
@staticmethod
def f():
print('runoob');

C.f(); # 静态方法无需实例化
cobj = C()
cobj.f() # 也可以实例化后调用

map

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。

1
map(function, iterable, ...)
1
2
3
4
5
6
7
8
9
10
11
>>>def square(x) :            # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

# 提供了两个列表,对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

lambada表达式

又称为匿名函数,格式为 lambda 参数列表:函数体

1
2
3
4
5
6
7
8
9
g = lambda x:x+1
# 可这样认为,lambda作为一个表达式,定义了一个匿名函数,上例的代码x为入口参数,x+1为函数体
print(g(1))
----
2
# 写成函数形式:
def g(x):
return x+1
print(g(1))
1
2
3
>>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
>>> print filter(lambda x: x % 3 == 0, foo)
[18, 9, 24, 12, 27]

*list

列表元组的解包

首先定义一个函数

1
2
def myfun(a, b):
print(a + b)
1
2
3
4
5
6
7
8
n=[1,2]
print(*n)
out:1 2
>>> myfun(*n)
3
>>> m = (1, 2)
>>> myfun(*m)
3

函数作为函数参数

提高扩展性

1
2
3
4
5
6
7
8
9
10
11
def mysum(a,b):
return a+b
def mysub(a,b):
return a-b

def test(x,y,myfunc):
result = myfunc(x,y)
print(x,y,result)

test(10,20,mysum) # 10 20 30
test(10,20,mysub) # 10 20 -10

一个星号,两个星号的参数

1.带一个星号(*)参数的函数传入的参数存储为一个元组(tuple)

2.带两个星号(*)参数的函数传入的参数则存储为一个字典(dict),并且再调用是采取a=1,b=2,c=3的形式

3.传入的参数个数不定,所以当与普通参数一同使用时,必须把带星号的参数放在最后。

1
2
3
4
5
6
7
8
9
10
11
12
def function_with_one_star(*d):
print(d, type(d))

def function_with_two_stars(**d):
print(d, type(d))

# 上面定义了两个函数,分别用了带一个星号和两个星号的参数:
function_with_one_star(1, 2, 3)
function_with_two_stars(a = 1, b = 2, c = 3)
-----
(1, 2, 3) <class 'tuple'>
{'a': 1, 'b': 2, 'c': 3} <class 'dict'>https://blog.csdn.net/weixin_41896508/article/details/80771817>

Re:

https://blog.csdn.net/weixin_41896508/article/details/80771817

if help:小手一抖点个广告 or 大手一挥资助一下