Python总结

一、格式化输出的方法

1.占位符

方式一

msg = "我叫%s,是一名%s,已经工作了%d年" % ("王大锤","码农",5)
print(msg)

#结果
我叫王大锤,是一名码农,已经工作了5年

 

方式二

msg = "我叫%(name)s，是一名%(job)s，已经工作了%(year)d年" % {'name' : "王大锤" , 'year' : 5 , 'job' : "码农"}
print(msg)

#结果
我叫王大锤，是一名码农，已经工作了5年

 

2.format

方式一

msg = "我叫{},是一名{},已经工作了{}年".format("王大锤","码农",5)
print(msg)

#结果
我叫王大锤,是一名码农,已经工作了5年

 

方式二

msg = "我叫{2},是一名{0},已经工作了{1}年".format("码农",5,"王大锤")
print(msg)

#结果
 我叫王大锤,是一名码农,已经工作了5年

 

方式三

msg = "我叫{name},是一名{job},已经工作了{year}年".format(name='王大锤',year=10,job='码农')
print(msg)

#结果
我叫王大锤,是一名码农,已经工作了10年

 

方式四：

 

dic = {'name':'xiaoming','hobby':'music'}
s = '{dic[name]} like {dic[hobby]}'.format(dic=dic)
print(s)

# 结果
xiaoming like music

 

 

3.join

 方式一

list = ["我","叫","王","大","锤",]
print("-".join(list))

#结果
我-叫-王-大-锤

 

二、面试题

① 列表list去重的方法

把列表转化成集合去重，在转换为列表，因为集合的元素是不重复的

lis = [0,1,1,2,3,4,5,2,3,9,6,'a','b','c','a',True,False,'b',False,True]
set1 = set(lis)
print(set1)
print(list(set1))

# 结果
{0, 1, 2, 3, 4, 5, 6, 9, 'c', 'a', 'b'}
[0, 1, 2, 3, 4, 5, 6, 9, 'c', 'a', 'b']

 

 

② 什么是深拷贝，什么是浅拷贝?

li2 = li1[:]　 属于哪种拷贝

答：浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。(比深拷贝更加节省内存)；对于要拷贝的对象要复制一份，但是对于其内部的子对象就不复制了，而是直接引用

　　深拷贝 拷贝对象及其子对象；深拷贝就是把要拷贝的对象整体复制一份，存在新开辟的空间里；

　　li2 = li1[:] 属于浅拷贝

 

③ 创建字典的方式

方式一：

dic = {'a':1,'b':2,'c':3}
print(dic)

# 结果
{'a': 1, 'b': 2, 'c': 3}

 

方式二：

dic = dict()
dic1 = dict([('a','b'),(1,2,)])
dic2 = dict([('name','xiaoming'),('haha','xixi')])
dic3 = dict(a=1,b=2,c=3)
print(dic)
print(dic1)
print(dic2)
print(dic3)

# 结果
{}
{'a': 'b', 1: 2}
{'name': 'xiaoming', 'haha': 'xixi'}
{'a': 1, 'b': 2, 'c': 3}

 

方式三：

dic = dict.fromkeys(['a','b','c'],[1,2,3])
print(dic)

# 结果
{'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3]}

 

二、数据类型的转换

int ---> str

s1 = str(100)
print(s1,type(s1))

# 结果
100 <class 'str'>

 

str ---> int

i1 = int('100')
print(i1,type(i1))

# 结果
100 <class 'int'>

 

 

int ---> bool

i1 = 1
i2 = 0
b1 = bool(i1)
b2 = bool(i2)
print(b1,b2)

# 结果
True False

 

bool ---> int

i1 = int(True)
i2 = int(False)
print(i1,i2)

# 结果
1 0

 

str ---> bool

b1 = bool('abc')
b2 = bool("")
print(b1,b2)

# 结果
True False

 

bool ---> str （无意义）

s1 = str(True)
s2 = str(False)
print(s1,type(s1))
print(s2,type(s2))

# 结果
True <class 'str'>
False <class 'str'>

 

str ---> list

s1 = 'a b c d e'
lis = s1.split()
print(lis)

# 结果
['a', 'b', 'c', 'd', 'e']

 

list ---> str

lis = ['h','e','l','l','o']
s1 = ''.join(lis)
print(s1)

# 结果
hello

 

list ---> set （用于列表去重）

lis = [1,2,3,5,6,0,1,0,9,'a','b','c','b',5,6,'c',True,False,'a',1,0,False]
set1 = set(lis)
print(set1)

# 结果
{0, 1, 2, 3, 'b', 5, 6, 'c', 9, 'a'}

 

set ---> list

set1 = {True,0,False,1,3,6,'a','c'}
lis = list(set1)
print(lis)

# 结果
[0, True, 3, 'c', 6, 'a']

 

list ---> tuple

lis = [1,2,3,'a','b','c']
tu = tuple(lis)
print(tu)

# 结果
(1, 2, 3, 'a', 'b', 'c')

 

tuple ---> list

tu = ('a','b','c',3,2,1)
lis = list(tu)
print(lis)

# 结果
['a', 'b', 'c', 3, 2, 1]

 

dict ---> list　　（将字典的所有键key转换为列表）

dic = {'a':1 , 'b':2 , 'c':3}
lis = list(dic)
print(lis)

# 结果
['a', 'b', 'c']

 

list ---> dict  （正常情况下不能转换，使用字典创建的方式来转换）

lis = ['a','b']
dic = dict([lis,(1,2)])
print(dic)

# 结果
{'a': 'b', 1: 2}

 

dict ---> set

dic = {'a':1 , 'b':2 , 'c':3}
set1 = set(dic)
print(set1)

# 结果
{'b', 'a', 'c'}

 

set ---> dict  （正常情况下不能转换，使用字典创建的方式来转换）

set1 = {'a','b'}
dic = dict((set1,(1,2,)))
print(dic)

# 结果
{'b': 'a', 1: 2}

 

数据结构

https://blog.csdn.net/dongrixinyu/article/details/78775057