企业面试题

15.python新式类和经典类的区别？

（在Python 2及以前的版本中，由任意内置类型派生出的类（只要一个内置类型位于类树的某个位置），都属于“新式类”，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类，则称之为“经典类”。

“新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。）

a. 在python里凡是继承了object的类，都是新式类

b. Python3里只有新式类

c. Python2里面继承object的是新式类，没有写父类的是经典类

d. 经典类目前在Python里基本没有应用

参考地址：https://www.cnblogs.com/blackmatrix/p/5630515.html

16.python中内置的数据结构有几种？

（python自带的数据结构可分为可变和不可变的。
可变的有：数组、集合、字典；
不可变的有：字符串、元组、数。）

a. 整型 int、 长整型 long、浮点型 float、 复数 complex

b. 字符串 str、 列表 list、 元祖 tuple

c. 字典 dict 、 集合 set

d. Python3 中没有 long，只有无限精度的 int

思考：

python内置数据结构

分类
数值型
int、float、complex、bool
数列对象
字符串 str
列表 list
tuple
键值对
集合set
字典dict
数值型
数值型
int、float、complex、bool都是class，1、5.0、2+3j都是对象即实例
int:Python3的int就是长类型，且没有大小限制，受限于内存区域的大小
float:有整数部分和小数部分组成。支持十进制和科学计数法表示。只有双精度型。
complex:有实数和虚数部分组成，实数和虚数部分都是浮点数，3+4.2j
bool:int的子类，仅有2个实例True、False对应1和0，可以和整数直接运算
类型转换（built-in）
int(x)返回一个整数
float(x)返回一个浮点数
complex(x)、complex(x,y)返回一个复数
bool(x)返回布尔值，前面讲过False等价的对象
数字的处理函数
round()，四舍五取偶六入
math模块、
floor():向下取整
ceil():向上取整
int():取整数部分
//:整除且向下取整
min():取最小值
max():取最大值
pow(x,y)等价于x**y
math.sqrt():开平方
进制函数，返回值是字符串
bin():二进制转换
oct():八进制转换
hex():十六进制转换
math.pi π
math.e 自如常数
类型判断
type(obj),返回类型，而不是字符串
isinstance(obj,class_or_tuple),返回布尔值
举例：
type(a)
type(‘abd’)
type(123)
isinstance(6,str)
isinstance(6,(str,bool,int))
列表list
一个排列整齐的队列
列表内的个体称为元素，由若干个元素组成列表
元素可以是任意对象（数字、字符串、对象、列表等）
列表内元素有顺序，可以使用索引
线性数据结构
使用[]表示
列表是可变的
列表list定义 初始化
list() 生成一个新列表
list(iterable) 可将可循环结构转化为列表
列表不能一开始就定义大小
举例
lst=list()
lst=[]
lst=[2,3,’adfa’]
lst=list(range(5))
列表索引访问
索引，也叫下标
正索引：从左至右，从0开始，为列表中的每一个元素编号
负索引：从右至左，从-1开始
正负索引不可以越界，否则引发异常indexError
列表通过索引访问
list[index],index就是索引，使用中括号访问
列表查询
index(value,[start,[stop]])
通过值valaue，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
count（value）
返回列表中匹配value的次数
时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，效率下降
len()
列表元素修改
索引访问修改
list[index] = value
索引不要越界
列表增加、插入元素
append(object) -> None
列表尾部追加元素，返回None
不产生新列表，就地修改
时间复杂度O(1)
insert(index,object) -> None
在指定的索引index处插入object
不产生新的列表，就地修改
时间复杂度是O(n)
索引超出上下界
超越上届，尾部追加
超越下届，头部追加
列表增加，插入元素
extend(iteratable) -> None
将可迭代对象的元素追加进来，返回None
就地修改
-> list
连接操作，将两个列表连接起来
产生新的列表，原来列表不变
本质上是调用add()方法
列表*重复的问题
pass

列表删除元素
remove(value) -> None
从左至右查找第一个匹配value的值，移除该元素，返回None
就地修改
时间复杂度是O(n)
pop([index]) -> item

不指定索引index，就从尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
时间复杂度
指定索引是O(n)
不指定是O(1)
clear() -> None

清除列表内所有的元素
列表其他操作
reverse() -> None
将列表元素反转，返回None
就地修改
sort(key=None,reverse=False) -> None
对列表元素进行排序，就地修改，默认升序
reverse为True,反转，降序
key一个函数，指定key如何排序
in
[3,4] in [1,2,[3,4]]
for x in [1,2,3,4]
列表复制
copy() -> List
shadow copy 影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已。
深拷贝
copy 模块提供了deepcopy
随机数
random模块
randint(a,b) 返回a，b之间的整数
choice(seq)从非空序列的元素中随机挑选一个元素
randrange([start,] stop [,sttep])从指定范围内，按指定基数递增的集合中获取一个随机数
random.shuffle(list) ->None 就地打乱列表元素
sample(population, k)从样本空间或总体中随机取出k个不同的元素，返回一个新的列表
元组 tuple
一个有序的元素组成的集合
使用小括号() 表示
元组是不可变对象
元组的定义 初始化
定义

tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable’s items
举例

t = tuple()
t = ()
t = tuple(range(1,7,2)
t = (2,3,4,6,7)
t = (1,)
t = (1,2,3) * 6

元组元素的访问
支持索引
正索引：从左至右，从0开始，为列表中每一个元素编号
负索引：从右至左，从-1开始
正负索引不可以超界，否则引发异常IndexError
元组通过索引访问
tuple[insex],index就是索引，使用中括号访问
元组查询
index(value,[start,[stop]])
通过值value，从指定区域查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueErroe
count(value)
返回列表中匹配value的次数
时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，而效率下降
len(tuple)
返回元素的个数
元组其他操作
元组是只读的，所以增、改、删的方法都没有
字符串
一个个字符组成的有序的序列，是字符的集合
使用单引号、双引号、三引号引住的字符序列
字符串是不可变对象
Python3，字符串就是Unicode类型
字符串定义 初始化
举例

s1 = 'string'
s2 = "string2"
s3 = '''this`s a "string" '''
s4 = 'hello \n magedu.com'
s5 = r"hello \n magedu.com"
s6 = 'c:\windows\nt'
s7 = R"c:\windows\\nt"
s8 = 'c:\windows\\nt'
sql = """select * from user where name='tom'"""

字符串元素访问
字符串支持使用索引访问
有序的字符集合，字符序列
可迭代
字符串joinlianjie
“string”.join(iterable) -> str
将可迭代对象连接起来，使用string作为分隔符
可迭代对象本身元素都是字符串
返回一个新字符串
举例

lst = ['1','2','3'] 
print("\"".join(lst)) 
print("\n".join(lst)) 
lst = ['1',['a','b'],'3'] 
print(" ".join(lst)

字符串 + 连接
+-> str
将2个字符串连接在一起
返回一个新字符串
字符串分割
分割字符串的方法分为2类
split
将字符串按照分隔符分割成若干字符串，并返回列表
partition
将字符串按照分隔符分割成2段，返回这2段和分隔符的元组
split(sep=None,maxsplit=-1) - > list of strings
从左至右
sep指定分割字符串，缺省的情况下空白字符串作为分隔符
maxsplit指定分割次数，-1表示遍历整个字符串
举例

s1 = "i`m \ta super student." 
s1.split() 
s1.split('s') 
s1.split('super') 
s1.split('super ') 
s1.split('') 
s1.split('',maxsplit=2) 
s1.split('\t',maxsplit=2) 

rsplit(sep=None,maxsplit=-1)-> list of string
从右至左
sep指定分割字符串，缺省的情况下空白字符串作为分隔符
maxsplit指定分割次数，-1表示遍历整个字符串
splitlines([keepends]) -> list of strings
按照行来切分字符串
keepends指的是是否保留分隔符
行分隔符包括\n、\r\n、\r等
partition(sep) -> (head,sep,tail)
从左至右，遇到分隔符酒吧字符串分割成两部分，返回头，分隔符，尾三部分；如果没有找到分隔符，就返回头，2个空元素的三元组
sep分割字符串，必须指定
rpartiton(sep) -> (dead, sep, tail)
从右至左，遇到分隔符酒吧字符串分割成两部分，返回头，分隔符，尾三部分；如果没有找到分隔符，就返回头，2个空元素的三元组
字符串大小写
upper()
全大写
lower()
全小写
大小写，做判断的时候用
swapcase()
交互大小写
字符串排版
title() -> str
标题的每个单词都大写
capitalize() -> str
首个单词大写
center(width[, fillchar]) -> str
width 打印宽度
fillchar 填充的字符
zfill(width) -> str
width 打印宽度，居右，左边用0填充
ljust(width[,fillchar]) -> str 左对齐
rjust(width[,fillchar]) -> str 右对齐
字符串修改
replace(old, new[,count]) -> st
字符串中找到匹配替换为新子串，返回新字符串
count表示替换几次，不指定就是全部替换
strip([chars]) -> str
从字符串两端去除指定的字符集chars中的所有字符
如果chars没有指定，去掉两端的空白字符
lstrip([chars]) -> str
从左开始
rstrip([chars]) -> str
从右开始
字符串查找
find(sub[, strat[, end]]) -> int
在指定的区间[start, end],从左至右，查找子串sub。找到返回索引，没找到返回-1
rfind(sub[, strat[, end]]) -> int
index(sub[, start[, end]]) -> int
在指定的区间[start,end),从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
rindex(sub[, start[, end]]) -> int
在指定的区间[start,end),从右至左，查找子串sub。找到返回索引，没找到抛出异常ValueError
时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，而效率下降
len(string)
返回字符串的长度，即字符的个数
count(sub[,start[, end]]) -> int
在指定区间[start, end),从左至右，统计子串sub出现的次数
字符串判断
endswith(suffix[, start[, end]]) -> bool
在指定的区间[start, end),字符串是否是suffix结尾
startwith（prefix[,start[, end]]）-> bool
在指定的区间[start, end),字符串是否是suffix开头
字符串判断is系列
isalnum() -> bool 是否是字母和数字组成
isalpha() 是否是字母
isdecimal() 是否只包含十进制数字
isdigit()是否包含全部数字(0-9)
isidentifer()是不是字母和下划线开头，其他嗾使字母、数字、下划线
islower()是否都是小写
isupper()是否全部大写
isspace() 是否只包含空白字符
字符串格式化
字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
join拼接只能使用分隔符，且要求被拼接的是可迭代的对象
+ 拼接字符串还算方便，但是非字符串需要先转化为字符串才能呢个拼接
format函数格式字符串语法
”{} {xxx}”.format(*args,**kwargs) -> str
args是位置参数，是一个元组
kwargs是关键字参数，是一个字典
花括号表示占位符
｛｝表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
{xxx}表示在关键字参数中搜索名称一致的
{{}}表示打印花括号
位置参数

"{}:{}".format('192.168.1.100',8888)
这就是按照位置顺序用位置参数替换前面的格式字符串的占位符中

关键字参数或命名参数

"{server} {1}:{0}".format(8888,'192.168.1.100', server='Web Server Info:')
位置参数按照序号匹配，关键字参数按照名词匹配

访问参数

"{0[0]}.{0[1]}".format(('magedu','com'))

对象属性访问

from collections import namedttuple
Point = namedtuple('Point','x y')
p = Point(4,5)
"{{{0,x},{0,y}}}".format(p)

对齐

'{0}*{1}={2:<2}'.format(3,2,2*3)
'{0}*{1}={2:<02}'.format(3,2,2*3)
'{0}*{1}={2:>02}'.format(3,2,2*3)
'{:^30}'.format('centered')
'{:*^30}'.format('centered')

进制

"int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
"int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
octets = [192, 168, 0, 1]
'{:02X}{:02X}{:02X}{:02X}'.format(*octets)

参考地址：https://blog.csdn.net/mini_xiang/article/details/79732520

Python基本内置数据类型有哪些

一些基本数据类型，比如：整型（数字）、字符串、元组、列表、字典和布尔类型。

随着学习进度的加深，大家还会接触到更多更有趣的数据类型，python初学者入门时先了解这几种类型就可以了。

基本内置数据类型对应符号

1）整型——int——数字
python有5种数字类型，最常见的就是整型int。例如：1234、-1234

2）布尔型——bool——用符号==表示
布尔型是一种比较特殊的python数字类型，它只有True和False两种值，它主要用来比较和判断，所得结果叫做布尔值。例如：3==3 给出True，3==5给出False

3）字符串——str——用' '或" "表示
例如：'www.iplaypython.com'或者"hello"

4）列表——list——用[ ]符号表示
例如：[1,2,3,4]

5）元组——tuple——用( )符号表示
例如：（'d',300）

6）字典——dict——用{ }符号表示
例如：｛'name':'coco','country':'china'｝

Python基本数据类型中哪些可变，哪些是不可变

python可变数据类型：列表list[ ]、字典dict{ }

python不可变数据类型：整型int、字符串str' '、元组tuple（）

 参考地址：https://blog.csdn.net/wk022/article/details/50297303