Python123中的选择题

一句话知识点：

1.  'R\0S\0T'长度为5.\0算一个转义字符
	r'\0s\0t' 长度为6.r使字符串中的\取消转义的含义
2.//整除 返回一个整数。 /真除法，返回一个浮点数

3.空字符串可以表示或

4.python没有主函数的说法，自顶向下顺序执行

5. 0.1+0.2！=0.3#因为十进制在转换成计算机识别的二进制的时候不能精确表示
			   #二进制只能精确表示1/2,1/4等，它不能精确表示十进制的0.1，所以会出现误差

6.\是转义符，所以在表示路径时，可以用//,/,\\代替

7.字符串和列表的比较规则：
  从第一位开始比较编码，若不同则返回结果。若前面全部相同则比较长度

8.能够表示多个数据的类型称为组合数据类型。分为三类：集合，序列（元组，列表，字符串），映射（字典）

9.浮点数的计算结果会溢出，整数不会溢出。
  整数没有长度限制，浮点数有长度限制，受限于内存大小

10.当多次导入同一模块时，该模块中的代码仅在首次导入时执行

11.字典中的pop(key):键存在则返回相应的值，并且删除键值对，否则报错。key必须有，不存在会报错
          popitem():随机从字典选择一个键值对，以元组形式返回，同时删除

12.使用rmdir()删除目录之前要先清除其中所有的文件，否则会报错

13.函数定义时的参数称为形参，调用时的参数称为实参
   可变参数 *param：接收多个位置收集的实参组成一个元组
          **param 接收多个关键字参数收集的实参名和值组成一个字典

14.元组可以直接相加。(2,1)+(0,2)=(2,1,0,2)

15.a is b  表示a和b的id是否相同

16.syntaxError语法错误。代码中出现了无法解释执行的符号。

17.int()可将整数字符串、浮点数转化为整数。但不能将浮点数字符串转化为整数
	int('1') >>>1
	int(1.9) >>>1
	int('1.2') >>>报错

18.isspace()判断字符串是否全为空格

19.ls='ab'
   print('{:->4}'.join(ls)) >>>a{:->4}b

20.l1=[1,2];l2=[1,2]#l1和l2的地址不同
   l2=l1#此时l2指向l1的地址，l2与l1的地址相同

21. >>> d={'a':1,'b':2}
	>>> d.items()
	dict_items([('a', 1), ('b', 2)])#整体是个列表，列表中包含元组
	>>> d.keys()
	dict_keys(['a', 'b'])
	>>> d.values()
	dict_values([1, 2])

22.方法返回值问题
	字符串中的方法需要有变量接收
	列表不需要变量接收，直接对原列表操作
	字典的增删改查不需要，其他需要
	w='fish520'
	for x in w:
		w.replace(x,'')
	>>>w不会改变，因为replace方法没有变量接收。w=w.replace(x,'')这样会改变

23. 自定义的函数名可以和Python内置函数名同名.
	不允许使用关键字作为变量名，可使用id作为变量名但不建议，可使用中文做变量名
	允许使用内置函数名做变量名

24.如果文件只被打开，文件内容不会装入内存。只有执行读取操作的时候才会把文件内容相应的长度装入内存

25.l.copy()复制列表，但不指向同一片内存空间

26.Python的__name__的作用是什么？
答：用来表示程序的运行方式。直接运行程序时其值为__main__,当作为模块导入时，其值为程序文件名

27.解释python基于值得内存管理模式
答：可以为不同的变量赋予相同的值，这个值在内存中只有一份，多个变量指向同一个内存地址。
  Python具有自动内存管理功能，会自动跟踪内存中所有的值，对于没有任何变量指向的值，Python会自动将其删除。

28.seq:分割值与值，默认为空格
	print(1,2,3,seq=':') >>>1:2:3
	print([1,2,3],sep=':') >>>[1, 2, 3]
	print([1,2,3],[1],sep=':') >>>[1,2,3]:[1]

29. 8**(1/3) >>>2.0
    -13//4   >>>-4    #余数必须为正
    abs(3+4j)>>>5.0 

30.isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
   isinstance() 与 type() 区别：
        type() 不会认为子类是一种父类类型，不考虑继承关系。
        isinstance() 会认为子类是一种父类类型，考虑继承关系。
   如果要判断两个类型是否相同推荐使用 isinstance()。

	a=2
	isinstance(a,int) >>>True
	isinstance (a,(str,int,list)) >>>第二个参数或者是一个元组，只要有一个符合就返回True

31. b:二进制   bin()二进制转十进制
	o:八进制   oct()八进制转十进制
	d:十进制
	x:十六进制 hex()十六进制转十进制

32.'+='
	对于列表而言，相当于extend（），属原地操作
	对于整数、实数、字符串、元组这样的不可变类型，不是原地操作
	a=[1,2]
	a+=[3]和b+=[3]的地址不同

33.使用切片在列表开头添加元素
	a=[1，2]
	a[0:0]=[2]    >>>[2,1，2]
	a[0:1]=[3]    >>>[3,2]

34.sorted([1,2,3],reverse=True) != reversed([1,2,3])
	前者返回[3,2,1]，后者返回一个反转的迭代器。list(reversed([1,2,3]))返回[3,2,1]

35.max([111,22,3],key=str)#将列表元素的str类型进行比较
	返回3.'3'>'1'

36. x=[3,5,3,7]
	[x.index(i) for i in x if i==3] >>>[0,0]
	语法：index(str,start,end)  start默认为0
	所以index（3）每次都从开头开始查找3的索引。

37.{1,2,3} | {3,4,5} 并集 >>>{1,2,3,4,5}
	{1,2,3} & {2,3,4} 交集 >>>{2,3}
	{1,2,3} - {3,4,5} 差集 >>>{1,2}

38.{1,2,3} == {2,3,1} >>>True
	集合是无序的，只要元素相同就相等，地址也是一样的。所以集合不支持下标访问元素
	集合中的元素可以是元组，不可以是列表。
	无法删除集合中指定位置的元素，只能删除特定值得元素
	{1,2}*2 报错  集合不能和int运算
	
39.(1,)+(2,)=(1,2)
	(1)+(2)=3

40.dict.update(dic2) 将dict2的键值对更新到dict里
	x={1:1,2:2}
	x.update({2:3,3:3})
	>>>x={1:1,2:3,3:3}#键2的值被更新为3

41.type({}) >>>dict
	一对大括号表示字典，不是集合

42.is和==的区别：
	is：判断内存地址是否相等
	==：判断值是否相等

43.x=list(range(10))
	x[::2]=[]>>>报错
	x[::2]=[2,4,6,8,10] >>>x=[2,1,4,3,6,5,8,7,10,9]
	#前     后数量要一致

44.（i**2 for i in range(100)）
>>>返回的是一个生成器对象，不是元组

45.Python的一个重要特性：惰性求值
x and y  当x为False时就不看y了
x or y 当x为True时就不看Y了。

46.当作为条件表达式时，空值、空字符串、空列表、空元组、空字典、空集合、空迭代对象以及任意形式的数字0都等价于False
例如:[]等价于None,但[]!=None.其余同理

47.filter()用于过滤序列，过滤掉不符合条件的元素，返回迭代器对象。
	filter(a,b) a-函数，b-序列
	序列的每个元素作为参数传递给函数进行判断，返回True or False,将True的元素放入新列表

48.lambda表达式属于可调用对象

49.在同一个作用域内，局部变量会隐藏同名的全局变量。

50.函数递归调用时对深度有限制

51.可以使用lambda表达式定义有名字的函数
	name=lambda x:x+5
	name(3) >>>8

52.lst('he wo') >>>['h','o',' ','w','o']

53.path=r'test.html'
path[:-4] >>>test.  #r不算

54.'%c'%65 >>>'A'
'%s'%65 >>>'65'
'%d'%65 >>>'65'

55.rindex(s) 从右侧开始检索s的位置，不存在返回-1
swapcase() 对字符串的大小写字母进行转换
str.upper()全部大写
str；lower(）全部小写
str.capitalize() 第一个字母转化成大写，其余小写(大写也会转成小写)
str.title() 每个单词首字母大写，其余小写（大写也会转成小写）
56.'aaasdf'.lstrip('as') >>>'df'
	'aaasdf'.lstrip('af') >>>'sdf'
	'aaasdf'.strip('af') >>>'sd'
	'aaasdf'.rstrip('af') >>>'aaasd'

57.uft8用3个字节表示一个汉字，gbk用2个字节表示一个汉字。
	都用一个字节表示英语字母

58.x in nums 的时间复杂度是O(n)
l.append() O(1)
l.insert() O(n)
delete()最后一个是O(1),中间是O(n)

59.Python中创建一个空列表后，内存中实际开辟了一个default大小的容量。当append时容量已满，会另外开辟2default大小的内存，先将原来内容复制过来再append
原来的列表会被python自动处理。

60.Python中变量就是变量，没有特定类型，因此不需要声明
但每个变量在使用前都必须复制，赋值以后才能被创建

61.aaa =[8, 5, 2, 2] 
	with open('output.txt', 'w') as f: 
	    for aa in aaa: 
	        f.write(';'.join(str(aa)))
>>> 8522#单个字符链接不会带上符号

62.变量是由用户定义的用来保存和表示数据的一种语法元素，没有长度限制

63.eval('3*4')  >>>12#没有引号哦 Int类型
当用户输入一个整数6，输出的是字符串形式的 '6'，如果需要得到整数6，加eval

64.函数ord(x)是返回字符串x对应的Unicode编码 （X）#字符x,不是字符串
divmod(x,y) >>>(x//y,x%y)

65.for i in range(5):
		pass
>>>print(i)   #i的值为4 

66.[start:end:step]
start:开始位置  end:结束位置
step:步长。正号表示从左往右，符号表示从右往左
k=[1,2,3,4,5,6,7]
k[3::-1]#表示从位置3（即元素4）开始从右往左取值. [4,3,2,1]

67.k=[1,2,3,4,5,6,7]
k[1:3] = 'abc'
>>>k    [1,'a','b','c',4,5,6,7]
k[1:3] = 23 #报错 整数只能赋值一位，只能k[2]=23.k[2:4]= '1'是可以的

68.def func(a,b,*args):
		return a,b,args
>>>func1(1,2,3,4,5,6)
>(1, 2, (3,4,5,6))#注意:可变数量参数用元组表示，函数返回多个值时也用元组表示

69.字典的fromkeys()方法
fromkeys(seq,value)
seq:列表，每个元素是字典的键
value：键的值，如果不指定则为None
d={}
d=d.fromkeys(['a','b'],2)
>>>{'a':2,'b':2}

70.函数没有return时，返回值为None

71.表达式3*4**2//8%7的值：6
	**优先级最高，先算4**2

72.type(type('45')) >>> <class 'type'>

73.finally:无论try语句中是否抛出异常，finally中的语句一定会被执行
注意：try块中包含break、continue或者return语句的，在离开try块之前，finally中的语句也会被执行。

def func1():
    try:
        print 'in func1 try: try statement, will return 1'
        return 1
    finally:
        print 'in func1 finally: try statement, will return 2'
        return 2
 
def func2():
    try:
        print 'in func2 try: raise error'
        raise ValueError()
    except:
        print 'in func2 except: caught error, will return 1!'
        return 1
    finally:
        print 'in func2 finally: will return 3'
        return 3
 
print func1()
print func2()

>>> in func1 try: try statement, will return 1
	in func1 finally: try statement, will return 2
	2
	in func2 try: raise error
	in func2 except: caught error, will return 1!
	in func2 finally: will return 3
	3

74. img1 = ["aa","bb","cc","dd"]
	img2 = [1,2,3,4,5]
	def modi():
	    #global img1
	    img1 = img2
	    print(img1)
	modi()
	print(img1)
>>>[1, 2, 3, 4, 5]
	['aa', 'bb', 'cc', 'dd']#函数内部的image1是局部变量，和外面的imag1不是同一个变量

def mode1():
	print(imag1)
>>> ["aa","bb","cc","dd"]#直接打印的话就是外面的

75.try:
   n = 0
   n = input("请输入一个整数: ")
   def pow10(n):
      return n**10
   #pow(n)
except:
   print("程序执行错误")

>>>无输出，因为没有调用函数.如果调用注释的那句，就会执行except

1.如果只想要对字符串的前几位进行格式化，可以用小数点。

 print('{:*^10.4}'.format('Flower'))

2.注意运算顺序，先算10/9，再乘5

print("{:.2f}".format(20-2**3+10/3**2*5))
#12+（10/9）*5

3.转义符的作用。
直接出现单引号 ’ 表示字符串定义符，如果想让它只代表一个单引号就需要在前面加一个
或者用双引号来表示

chr = "|'\'-'|"
#输出 |''-'|
s="'"#表示一个单纯的单引号
s2='"'#表示一个单纯的双引号

4.常见random函数

import random
random.randint(1,10)#产生1到10的随机整数
random.random()#产生0到1的随机浮点数。不允许带参数
random.uniform(1.1,5.4)#产生1.1到5.4之间的随机浮点数。参数可以不是整数
random.choice('tomorrow')#从序列中随机选择一个元素
random.randrange(1,100,2)#生成1到100之间间隔为2的随机整数
random.shuffle([1,2,3])#打乱序列中的元素
random.sample(l,k)#返回l中的随机k个数（保证不重复）.当k==len(l)时，返回的值的顺序和原l也不一定一样.
				  #适用于列表集合元组字符串.结果都是返回一个列表

5.while和for循环中的else用法：

x=10
while x:
	x-=1
	if x%2:
		print(x,end='')
else:
	print(x)

输出975310。当while循环正常结束时执行else

x=10
while x:
	x-=1
	if x%2:
		print(x,end='')
	else:
		break
else:
	print(x)

输出结果为9。因x=8时会break出while循环，while循环非正常退出时不会执行else语句

for循环同理哦！！！

6.all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

元素除了是 0、空、None、False 外都算 True。

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。

7.

a='1'
>>>a
>'1'#a加一个引号是为了表示它是字符串类型的1
>>>print(a)
>1#实际上a就是1，只不过类型为str

j = ''
for i in "12345":
    j += i + ','
print(j)
>>>1,2,3,4,5,#不加引号

8.

img1 = [12,34,56,78]
img2 = [1,2,3,4,5]

def displ():
    print(img1)
def modi():
    #global img1
    img1 = img2#这里的img1是局部变量，与全局变量img1不是同一个。除非添加一个global声明

modi()
displ()
>>>[12,34,56,78]
>>>[1,2,3,4,5]#添加global声明后

9.str(列表)

x=[1,23,456]
a=str(x)
>>>a
>>>'[1, 23, 456]'#从第二个元素开始，每个元素前都多了一个空格
>>>len(a)#长度为12
a中每个元素都是一个字符串形式。

10一个小细节吧。容易懵

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)#这样输出时没有逗号的
    print(k+','+v)
>>> gallahad the pure
	gallahad,the pure
	robin the brave
	robin,the brave
    

11文件方面
open（）函数用于打开一个文件（不能创建），但会创建一个file对象

#各种模式
#r-读  w-写  a-追加  x-写模式，新建一个文件
#添个加号+表示可以读写
#加个b表示对二进制文件进行操作,t是对文本文件操作
#w类和a类当文件不存在时都会创建新文件。x模式找那个如果文件已存在会报错
#r和w类打开文件时指针在开头，a类指针在末尾

seek（num）定位文件指针位置。num可选0：开头，1：当前，2：末尾
tell()返回文件指针的当前位置

txt=open('file','r')
print(txt)#不会输出文件内容。只是打开了，啥也没干。

writelines（）直接将列表类型的各元素连接起来写入文件中
ls=['C','java']
writelines(ls) >>>写入文件的是  Cjava

read() readline() readlines()都会将换行符计算在内
#txt:
#星星
#123
with open('txt') as f:
	data1=f.read()#默认将所有内容原封不动存到data1中

#如果 data1=f.read(3)           data1=f.read(4)
>>>星星						>>>星星
>>>    #这里会有一个换行符		>>>1

with open('txt') as f:
	data2=f.readline()
>>>星星 #长度为3，最后有一个换行符

with open('txt') as f:
	data3=f.readlines()
>>>['星星\n','123']#返回一个列表。由每行一个字符串构成。最后一行末尾无换行符

with open('txt') as f:
	data1=f.read()
	data2=f.read()
	data3=f.readline()
	data4=f.readlines()
data1会读出内容，data2不会，因为data1读完指针会放在末尾。
data2和darta3返回一个空字符串，data4返回一个空列表

文件包括文本文件和二进制文件，都采用打开-操作-关闭。文件中可包含任何数据内容
采用文本读入文件，文件经过编码形成字符串
采用二进制方式读入问价，文件被解析成字节流

当读取一个文本文件时，注意会读出换行符'\n'。
用字典统计字符后，可使用del d['\n']删除

write和writelines区别：
write()需要传入一个字符串作为参数，否则报错
writelines()既可传入字符串又可传入字符序列。
例如：l=['123','456'] writelines(l) >>>123456
	但不可传入数字序列如[1,2,3]，会报错

read()返回全部内容，类型为str
readline()返回一行内容，类型为str
readlines()返回一个列表，['1\n', 'b\n', '1']

12

def func(x):
	return x**2+6
>>>fun(8)#没有输出结果.需要print(fun(8))
def func(x):
	print（ x**2+6）
>>>fun(8)#输出70

13 类的整理

1.基本语法
class Car():#如果派生自其它基类则需要把所有基类放在一个括号，用逗号隔开
	def infor(self):
		print('This is a car')
定义类后，可实例化对象，并通过 对象名.成员 的方式访问其中的数据成员或方法。
car = Car()#实例化对象
car.infor()#调用对象的成员方法

可使用内置函数isinstance()来测试一个对象是否为某个类的实例
isinstance(car,Car) >>>True

在python中，type是一个特殊的类，可以看做是所有类型的基类

_xxx:以一个下划线开头，保护成员，只有类对象和子类对象可以访问这些成员，在模块中使用一个或多个下划线开头的成员不能用 from m import *导入
__xxx__:前后各两个下划线，系统定义的特殊成员。
__xxx:以两个或多个下划线开头但不以两个或更多下划线结束，表示私有成员。
私有成员通过 对象名._类名_xxx 的特殊方式访问

类成员或实例成员（或者说属性）
实例属性：构造函数__init__()中定义的。
		定义和使用必须以self为前缀
		实例属性属于实例，只能通过对象名访问
类属性：类中所有方法以外的数据成员。
	  类属性属于类，可通过类名或对象名访问

14关于Python中的复数

1.表示复数的语法：real+imag j
2.实部和虚部都是浮点数
3.虚部的后缀是j或J
4.复数的conjugate方法，可返回共轭复数。