python面试题

一行代码实现 1-100之和？

print(sum(range(1,101)))

如何在一个函数内部修改全局变量

# 使用global关键字
a = 10
def fn():
    global a
    a = 4
fn()
print(a) # 4

列出5个python标准库

# os 模块
# re 模块
# sys 模块
# math 模块
# datetime 模块
# time 模块
# json  模块
# pickle 模块

字典如何删除键和合并两个字典

dic = {"name":"fuqiang"}
dic1 = {}
# 删除字典
del dic
# 合并
dic1.update(dic)

谈一下 python 的 GIL

GIL锁，是python的全局解释器锁，同一进程中，假如有多个线程运行，一个线程在运行的python程序的时候会占用python解释器(就是加了一把GIL锁),在进程内的其他线程无法运行，等该线程运行完后，GIL锁释放掉，其他的线程才可以运行。如果线程运行时遇到耗时的操作，则解释器锁释放，使其他线程运行。所以在多线程中，线程的运行仍有先后顺序的，并不是同时进行的。

python实现列表去重的方法

list1 = [1,2,3,4,5,4,3,2,1]
set1 = set(list1)
list2 = [i for i in set1]

fun(*args,**kwargs)中的 *args, **kwargs 什么意思?

*args和**kwargs 是函数的参数列表，其中*args是位置参数，**kwargs是关键字参数，这两个参数都是不定长的。
*args 返回的是元组的数据接口
**kwargs 返回的是字典的数据结构

python2和python3的range(100)的区别？

# python2
range(100)  # [1,2,3,4,...,98,99]  返回的是列表，如果也想在python2中使用迭代器的话，就需要使用xrange(100)
# python3
range(100)  # range(100) 返回的是迭代器

一句话解释什么样的语言能够用装饰器?

函数可以作为参数传递的语言可以使用装饰器

Python的内建数据类型有哪些？

整型--int

布尔型--bool

字符串--str

列表--list

元组--tuple

字典--dict

简述面向对象中__new__和__init__区别?

1. __new__ 至少要有一个参数cls,代表当前类，此参数在实例化时由Python解释器自动识别。必须要有返回值，返回一个实例。
2. __init__ 有一个参数self,就是这个__new__返回的实例，__init__ 在 __new__的基础上完成一些初始化的动作，__init__ 不需要返回值。

简述with方法打开处理文件帮我我们做了什么？

```python
打开文件进行读写的时候，可能会出现异常，如果按照常规的f.open() 写法，我们需要使用异常捕获，而且文件不管遇到什么情况都需要进行关闭，with方法已经帮我们实现了finally中的f.close()方法
```

列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，并使用列表推导式提取出大于10的数，最终输出[16,25]

def pingfang(i):
    return i**2
tmp = map(pingfang,[1,2,3,4,5])
print(tmp)  # <map object at 0x000001AAC78F15C0>

tmp1 = [i for i in tmp if i>10]

print(tmp1)

python中生成随机整数、随机小数、0--1之间小数方法

# 1 导包
import random
# 2 生成指定区间的随机整数
random.randint(1000,9999)
# 3 生成随机小数
import numpy as np
np.random.randn(5) # 生成5个随机小数
# 4 生成0-1之间的随机小数
random.random()

避免转义给字符串加哪个字母表示原始字符串？
加上小写字母 r 可以表示是原始字符串，不转义特殊的字符
<div class="name">中国</div>，用正则匹配出标签里面的内容（“中国”），其中class的类名是不确定的。

```python
import re

str1 = ‘<div class="name">中国</div>‘

tmp = re.findall(r‘<div class=".*">(.*?)</div>‘,str1)

print(tmp)
```

python中断言方法举例
assert（）方法，断言成功，则程序继续执行，断言失败，则程序报错
```
a = 3
assert (a<10)
print("断言成功")
```
数据表student有id,name,score,city字段，其中name中的名字可有重复，需要消除重复行,请写sql语句
```
select distinct name from student ;
```

10个Linux常用命令

cd
touch
ps
chown
chmod
ls
cat
kill
pkill
find
mv
cp
echo 
tree
netstat
lsof
....

python2和python3区别？列举5个

```python
# py3 使用 print的时候 后面需要加一个小括号，可以理解是一个函数，py2的时候 可以写小括号的方式也可以不写。
# py3 使用range函数的时候，获取的值为一个迭代器，而py2使用range的时候，返回的是一个列表
# py3 默认的编码是unicode , py2 默认的编码是ascii
# py2 中 unicode 表示的是字符串序列，ascii 表示的是字节序列。py3 中的 str 表示的是字符串序列，byte表示的是字节序列。
# py2 显示中文需要在头部使用coding声明，而py3 则不需要。
# py2 的输入函数为raw_input 而py2 则是 input函数
```

列出python中可变数据类型和不可变数据类型，并简述原理。

# 不可变的数据类型: 整数型 字符串 和 元组，不允许变量的值发生变化，如果改变了值，等于重新生成了一个对象，变量的指针指向新生成的对象而已。可以使用id函数检测对象的id.
# 可变的数据类型：列表和字典
# 集合中的元素必须是不可变的数据类型

s = "ajldjlajfdljfddd"，去重并从小到大排序输出"adfjl"

s = "ajldjlajfdljfddd"

tmp = [i for i in set(list(s))]

tmp.sort()

tmp1 = "".join(tmp)

用lambda函数实现两个数相乘

sum = lambda a,b:a*b

tmp = sum(4,5)

print(tmp)

字典根据键从小到大排序

dic={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}

tmp = sorted(dic.items(),key=lambda i:i[0],reverse=False)

print(tmp) # [(‘age‘, 18), (‘city‘, ‘深圳‘), (‘name‘, ‘zs‘), (‘tel‘, ‘1362626627‘)]

利用collections库的Counter方法统计字符串每个单词出现的次数"kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"

from collections import Counter
a = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlkf;h"
b = Counter(a)
print(b) # Counter({‘l‘: 9, ‘;‘: 6, ‘h‘: 6, ‘f‘: 5, ‘a‘: 4, ‘j‘: 3, ‘d‘: 3, ‘k‘: 2, ‘s‘: 2, ‘g‘: 1, ‘b‘: 1})

字符串 "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h" 中 k出现的次数

a = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlkf;h"
tmp = a.count(‘k‘)
print(tmp)

字符串a = "not 404 found 张三 99 深圳"，每个词中间是空格，用正则过滤掉英文和数字，最终输出"张三深圳"

import re
a = "not 404 found 张三 99 深圳"

lis = a.split(‘ ‘)

str1 = ""

for i in lis:
    if not re.findall(r‘[0-9a-zA-Z]+‘,i):
        str1 += i+" "


print(str1) # 张三 深圳

filter方法求出列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

```python
a = [1,2,3,4,5,6,7,8,9]

def fn(a):
    return a%2==1

tmp = filter(fn,a)

b = [i for i in tmp]

print(b)
```

列表推导式求列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```
a =  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

tmp = [i for i in a if i%2==1]


print(tmp)
```

正则 re.complie作用

re.compile 是将正则表达式编译成一个对象，加快速度，并重复使用。

a=（1，）b=(1)，c=("1") 分别是什么类型的数据？
```
# a 是元组 
# b 是整型
# c 是字符串
```

两个列表[1,5,7,9]和[2,2,6,8]合并为[1,2,2,3,6,7,8,9]

a = [1,5,7,9]
b = [2,2,6,8]

a.extend(b)

a.sort()

print(a)  # [1, 2, 2, 5, 6, 7, 8, 9]

用python删除文件和用linux命令删除文件方法

```python
# python
import os
os.remove(‘readme.md‘)
# 用linux删除
os.system(‘rm -rf readme.md‘)
```

log日志中，我们需要用时间戳记录error,warning等的发生时间，请用datetime模块打印当前时间戳 “2018-04-01 11:38:54"
```
from datetime import datetime

tmp = datetime.now().strftime(‘%Y-%m-%d %H:%M:%S‘)

print(tmp)
```

数据库优化查询方法

1.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。

2.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：select id from t where num is null可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：select id from t where num=0

3.应尽量避免在 where 子句中使用!=或<>操作符，否则引擎将放弃使用索引而进行全表扫描。

4.应尽量避免在 where 子句中使用or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：select id from t where num=10 or num=20可以这样查询：select id from t where num=10 union all select id from t where num=20

5.in 和 not in 也要慎用，否则会导致全表扫描，如：select id from t where num in(1,2,3) 对于连续的数值，能用 between 就不要用 in 了：select id from t where num between 1 and 3

6.下面的查询也将导致全表扫描：select id from t where name like ‘%李%’若要提高效率，可以考虑全文检索。

7. 如果在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然 而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：select id from t where 可以改为强制查询使用索引：select id from t with(index(索引名)) where 

8.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：select id from t where num/2=100应改为:select id from t where num=100*2

9.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：select id from t where substring(name,1,3)=’abc’ ，name以abc开头的id应改为:
select id from t where name like ‘abc%’

10.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

11.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。

12.不要写一些没有意义的查询，如需要生成一个空表结构：select col1,col2 into #t from t where 1=0
这类代码不会返回任何结果集，但是会消耗系统资源的，应改成这样：
create table #t(…)

13.很多时候用 exists 代替 in 是一个好的选择：select num from a where num in(select num from b)
用下面的语句替换：
select num from a where exists(select 1 from b where num=a.num)

14.并不是所有索引对查询都有效，SQL是根据表中数据来进行查询优化的，当索引列有大量数据重复时，SQL查询可能不会去利用索引，如一表中有字段sex，male、female几乎各一半，那么即使在sex上建了索引也对查询效率起不了作用。

15. 索引并不是越多越好，索引固然可 以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。一个表的索引数最好不要超过6个，若太多则应考虑一些不常使用到的列上建的索引是否有 必要。

16. 应尽可能的避免更新 clustered 索引数据列，因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将导致整个表记录的顺序的调整，会耗费相当大的资源。若应用系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。

17.尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

18.尽可能的使用 varchar/nvarchar 代替 char/nchar ，因为首先变长字段存储空间小，可以节省存储空间，其次对于查询来说，在一个相对较小的字段内搜索效率显然要高些。

19.任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

20.尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。

21.避免频繁创建和删除临时表，以减少系统表资源的消耗。

22.临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表。

23.在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。

24.如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。
25.尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写。

26.使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效。

27. 与临时表一样，游标并不是不可使 用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时 间允许，基于游标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。

28.在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送DONE_IN_PROC 消息。

29.尽量避免大事务操作，提高系统并发能力。

30.尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理

请列出你会的任意一种统计图（条形图、折线图等）绘制的开源库，第三方也行

```python
pychart、matplotlib
```

写一段自定义异常代码

#1.用户自定义异常类型
class TooLongExceptin(Exception):
    "this is user‘s Exception for check the length of name "
    def __init__(self,leng):
        self.leng = leng
    def __str__(self):
        print("姓名长度是"+str(self.leng)+"，超过长度了")
        
#2.手动抛出用户自定义类型异常
def name_Test():
        name = input("enter your naem:")
        if len(name)>4:
            raise TooLongExceptin(len(name))  #抛出异常很简单，使用raise即可,但是没有处理，即捕捉
        else :
            print(name)

正则表达式匹配中，（.）和（.?）匹配区别？

# （.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配
# （.*?）是非贪婪匹配，会把满足正则的尽可能少匹配

简述Django的orm

ORM，全拼Object-Relation Mapping，意为对象-关系映射
实现了数据模型与数据库的解耦，通过简单的配置就可以轻松更换数据库，而不需要修改代码只需要面向对象编程,orm操作本质上会根据对接的数据库引擎，翻译成对应的sql语句,所有使用Django开发的项目无需关心程序底层使用的是MySQL、Oracle、sqlite....，如果数据库迁移，只需要更换Django的数据库引擎即可.

[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]

a = [[1,2],[3,4],[5,6]]
[j for i in a for j in i]

import numpy as np
a = [[1,2],[3,4],[5,6]]
np.array(a).flatten().tolist()

x="abc",y="def",z=["d","e","f"],分别求出x.join(y)和x.join(z)返回的结果

x = "abc"
y = "def"
z = ["d","e","f"]

x.join(y) # "dabceabcf"
x.join(z) # "dabceabcf"

举例说明异常模块中try except else finally的相关意义

try..except..else没有捕获到异常，执行else语句

try..except..finally不管是否捕获到异常，都执行finally语句

python中交换两个数值

a,b = 3,4
print(a,b)  # 3,4
a,b = b,a
print(a,b)  # 4,3

举例说明zip（）函数用法

zip()函数在运算时，会以一个或多个序列（可迭代对象）做为参数，返回一个元组的列表。同时将这些序列中并排的元素配对。

zip()参数可以接受任何类型的序列，同时也可以有两个以上的参数;当传入参数的长度不同时，zip能自动以最短序列长度为准进行截取，获得元组。

a="张明 98分"，用re.sub，将98替换为100

import re

a = "张明 98分"

ret = re.sub(r‘\d+‘,"100",a)

print(ret) # 张明 100分

写5条常用sql语句

1. show databases;
2. create databases 数据库名称;
3. use 数据库名称;
4. show tables;
5. select * from 表名 ;
6. insert into 表名(`字段名`) values(‘数据‘);
7. update 表名 set 字段名=值 where id=100;
8. delete from 表名 where id=100;

a="hello"和b="你好"编码成bytes类型

1. 第一种 强制转换 使用 bytes。但是必须指定编码方式.
a = "hello"
bytes(a,encoding=‘utf-8‘)
2. 第二种 使用encode()
a = "hello"
a.encode()

[1,2,3]+[4,5,6]的结果是多少？

# 相当于两个列表拼接，除了这种方式外，还可以使用 extend 进行列表的拼接
a = [1,2,3]
b = [4,5,6]
a+b  # [1,2,3,4,5,6]

a.extend(b)
print(a) # [1,2,3,4,5,6]

提高python运行效率的方法

1、使用生成器，因为可以节约大量内存

2、循环代码优化，避免过多重复代码的执行

3、核心模块用Cython  PyPy等，提高效率

4、合理的使用多进程、多线程、协程

5、多个if elif条件判断，可以把最有可能先发生的条件放到前面写，这样可以减少程序判断的次数，提高效率

简述mysql和redis区别

redis： 内存型非关系数据库，数据保存在内存中，速度快

mysql：关系型数据库，数据保存在磁盘中，检索的话，会有一定的Io操作，访问速度相对慢

遇到bug如何处理

1. 梳理业务逻辑
2. 断点调试
3. 查找一些技术博客以及官方文档

正则匹配，匹配日期2018-03-20

import re
url=‘https://sycm.taobao.com/bda/tradinganaly/overview/get_summary.json?dateRange=2018-03-20%7C2018-03-20&dateType=recent1&device=1&token=ff25b109b&_=1521595613462‘

tmp = re.findall(r‘dateRange=(.*)%7C(.*?)&‘,url)

print(tmp) # [(‘2018-03-20‘, ‘2018-03-20‘)]

list=[2,3,5,4,9,6]，从小到大排序，不许用sort，输出[2,3,4,5,6,9]

def quick_sort(arr):
    if len(arr) < 2:
        return arr
    mid = arr[0]
    left = quick_sort([i for i in arr[1:] if i<arr[0]])
    right = quick_sort([i for i in arr[1:] if i> arr[0]])
    return left + [mid] + right

list=[2,3,5,4,9,6]
tmp = quick_sort(list)

print(tmp)

手写单例模式

```python
class Singleton(object):
    instance=None
    lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls.instance:
            return cls.instance
        with cls.lock:
            if not cls.instance:
                cls.instance=super().__new__(cls)
        return cls.instance
```

保留两位小数

# 1. 保留两位小数 , 是四舍五入
a = "%.2f"%(1.33335) # 1.33
# 2. 保留两位小数 , 是四舍五入
b = round(1.33335,2) # 1.33

求三个方法打印结果

def fn(key, val, dict={}):
    dict[key] = val
    return dict


f1 = fn("one", 1)
f2 = fn("three", 3, {})
f3 = fn("two", 2)


print("f1:",f1)
print("f2:",f2)
print("f3:",f3)

‘‘‘
f1: {‘one‘: 1, ‘two‘: 2}
f2: {‘three‘: 3}
f3: {‘one‘: 1, ‘two‘: 2}
‘‘‘

列出常见的状态码和意义

请求正常处理完毕
  永久重定向，资源已永久分配新URI
  临时重定向，资源已临时分配新URI
  临时重定向，期望使用GET定向获取
  发送的附带条件请求未满足
  临时重定向，POST不会变成GET
  请求报文语法错误或参数错误
  需要通过HTTP认证，或认证失败
  请求资源被拒绝
  无法找到请求资源（服务器无理由拒绝）
  请求方法不被允许
  服务器故障或Web应用故障
  网关错误 (Bad gateway)
  服务器超负载或停机维护
  网关超时（Gateway timeout）

分别从前端、后端、数据库阐述web项目的性能优化

1. 前端
	1) 减少网络请求，比如说可以使用精灵图
	2） 页面布局要合理，比如说css需要放在头部，js一般放在最下面。
	3） 如果数据不发生变化，可以考虑使用真静态。
	
2. 后端
	1）常用数据使用缓存处理
	2）使用异步处理方式，比如说短信验证码或者邮箱验证码
	3）禁止在循环中查询sql语句
	4）条件判断语句，优先判断最容易发生的情况
	5）根据业务需求选择适合的框架
	
3. 数据库
	1) 可以考虑使用非关系型数据库，比如说redis等
	2）如果使用关系型数据库，需要建立适当的索引，字段的长度适当，查询的时候尽量使用字段名称，多使用where条件和limit语句。
	3）

使用pop和del删除字典中的"name"字段，dic={"name":"zs","age":18}
```
dic={"name":"zs","age":18}

dic.pop(‘name‘)

print(dic)
```

列出常见MYSQL数据存储引擎

InnoDB：支持事务处理，支持外键，支持崩溃修复能力和并发控制。如果需要对事务的完整性要求比较高（比如银行），要求实现并发控制（比如售票），那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，因为支持事务的提交（commit）和回滚（rollback）。 

MyISAM：插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出记录，那么选择MyISAM能实现处理高效率。如果应用的完整性、并发性要求比较低，也可以使用。

MEMORY：所有的数据都在内存中，数据的处理速度快，但是安全性不高。如果需要很快的读写速度，对数据的安全性要求较低，可以选择MEMOEY。它对表的大小有要求，不能建立太大的表。所以，这类数据库只使用在相对较小的数据库表

计算代码运行结果，zip函数历史文章已经说了，得出[("a",1),("b",2)，("c",3),("d",4),("e",5)]

tmp = zip([‘a‘,‘b‘,‘c‘,‘d‘],[1,2,3,4])
a = [i for i in tmp] # [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4), (‘e‘, 5)]

计算代码运行结果

s = dict([[‘name‘,‘zs‘],[‘age‘,18]])

s1 = dict([(‘name‘,‘zsf‘),(‘age‘,20)])

print(s) # {‘name‘: ‘zs‘, ‘age‘: 18}

print(s1) # {‘name‘: ‘zsf‘, ‘age‘: 20}

简述同源策略

同源策略的三要素：
	1） 协议
	2） 主机
	3） 端口
其中有任意一个不同，就不符合同源策略。

简述cookie和session的区别

cookie 存在于客户端  session 存在于服务端
cookie 长度大小限制在4k session 无具体限制
cookie 相对不安全   session相对安全
session的运行是依赖于session_id,而session_id则存在于cookie中，也就是说前端禁止使用cookie，后端session也就失效了。存储session时，健与cookie中的session_id相同，值是开发人员自行设置的，进行了base64的编码，过期时间也是由开发人员设置的。

简述多线程、多进程

1. 进程
	1) 操作系统进行资源分配和调度的基本单位，多个进程之间相互独立。
	2) 稳定性好，如果是一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制。
	
2. 线程
	1) CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能够独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有的资源。
	2) 如果I/O 操作密集，则可以使用多线程，运行效率高，缺点就是一个线程崩溃，就会造成进程的崩溃。

3. 协程

简述any() 和 all() 方法

```python
# any() : 只要迭代器中有一个元素为真，结果才为真。
# all() : 迭代器中所有的判断项为真，结果才为真。
any([1,2,3,False])  # True
all([1,2,3,False])  # False
```

python中什么元素为假?

答案：（0，空字符串，空列表、空字典、空元组、None, False）

IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError分别代表什么异常 ?

IOError：输入输出异常

AttributeError：试图访问一个对象没有的属性

ImportError：无法引入模块或包，基本是路径问题

IndentationError：语法错误，代码没有正确的对齐

IndexError：下标索引超出序列边界

KeyError:试图访问你字典里不存在的键

SyntaxError:Python代码逻辑语法出错，不能执行

NameError:使用一个还未赋予对象的变量

python中 copy和 deepcopy 区别?

1、复制不可变数据类型，不管copy还是deepcopy,都是同一个地址当浅复制的值是不可变对象（数值，字符串，元组）时和=“赋值”的情况一样，对象的id值与浅复制原来的值相同。
2、复制的值是可变对象（列表和字典）
	浅拷贝copy有两种情况：
        第一种情况：复制的 对象中无 复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。
        第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表）， 改变原来的值 中的复杂子对象的值  ，会影响浅复制的值。
     深拷贝deepcopy：完全复制独立，包括内层列表和字典

列出几种魔法方法并简要介绍用途

1. __init__ 对象初始化的方法
2. __new__  创建对象的时候调用，返回值为创建对象的实例
3. __str__  当使用print打印对象的时候，只要定义了这个方法，那么就会打印这个方法return的值
4. __del__  删除对象执行的方法

python 1.py 22 33命令行启动程序并传参，print(sys.argv)会输出什么数据？
```
>> python 1.py 22 33
>> [‘1.py‘,‘22‘,‘33‘]
```
请将[i for i in range(3)]改成生成器

```python
# 将 [ ] 换成 ( ) 就是生成器
tmp = (i for i in range(3))
print(tmp) # <generator object <genexpr> at 0x000002BA6F627CA8>
# 在函数中使用 yield 也可以是一个生成器
def index():
    for i in range(3):
        yield i
print(index()) # <generator object index at 0x000002BA6F627DB0>
```

a = " hehheh ",去除收尾空格

```python
tmp = a.strip()  
print(tmp) # hehheh
```

举例sort和sorted对列表排序，list=[0,-1,3,-10,5,9]

# 1
list=[0,-1,3,-10,5,9]
list.sort()
print(‘升序:‘,list)
list.sort(reverse=True)
print(‘降序:‘,list)

# 2
list=[0,-1,3,-10,5,9]
list1 = sorted(list,key=lambda x:x)
print(‘升序:‘,list1)
list2 = sorted(list,key=lambda x:x,reverse=True)
print(‘降序:‘,list2)

# 结果
‘‘‘
升序: [-10, -1, 0, 3, 5, 9]
降序: [9, 5, 3, 0, -1, -10]
升序: [-10, -1, 0, 3, 5, 9]
降序: [9, 5, 3, 0, -1, -10]
‘‘‘

对list排序foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4],使用lambda函数从小到大排序,输出的结果为[0,2,4,8,8,9,-2,-4,-4,-5,-20]，正数从小到大，负数从大到小
```
foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]

tmp = sorted(foo,key=lambda x:(x<0,abs(x)),reverse=False)

print(tmp) # [0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20]
```

列表嵌套字典的排序，分别根据年龄和姓名排序。

foo = [
    {"name":"zs","age":19},
    {"name":"ll","age":54},
    {"name":"wa","age":17},
    {"name":"df","age":23}
]

# 根据年龄排序
foo = [
    {"name":"zs","age":19},
    {"name":"ll","age":54},
    {"name":"wa","age":17},
    {"name":"df","age":23}
]

# 根据年龄排序
tmp = sorted(foo,key=lambda x:x[‘name‘])
print(tmp) # [{‘name‘: ‘df‘, ‘age‘: 23}, {‘name‘: ‘ll‘, ‘age‘: 54}, {‘name‘: ‘wa‘, ‘age‘: 17}, {‘name‘: ‘zs‘, ‘age‘: 19}]

#根据年龄排序
tmp = sorted(foo,key=lambda x:x[‘age‘])
print(tmp) # [{‘name‘: ‘wa‘, ‘age‘: 17}, {‘name‘: ‘zs‘, ‘age‘: 19}, {‘name‘: ‘df‘, ‘age‘: 23}, {‘name‘: ‘ll‘, ‘age‘: 54}]

列表嵌套元组，分别按字母和数字排序

foo = [
    ("zs",19),
    ("ll",54),
    ("wa",17),
    ("df",23)
]

# 根据名称排序
tmp = sorted(foo,key=lambda x:x[0])
print(tmp) # [(‘df‘, 23), (‘ll‘, 54), (‘wa‘, 17), (‘zs‘, 19)]

# 根据年龄排序
tmp = sorted(foo,key=lambda x:x[1])
print(tmp) # [(‘wa‘, 17), (‘zs‘, 19), (‘df‘, 23), (‘ll‘, 54)]

列表嵌套列表排序，年龄数字相同怎么办？

python面试题

相关推荐