helloworld
False
True
False
在 Python 中 _None__表示空类型.
None是一个特殊的常量。
None和False不同。
None不是0。
None不是空字符串。
None和任何其他的数据类型比较永远返回False。
None有自己的数据类型NoneType。
你可以将None复制给任何变量，但是你不能创建其他NoneType对象。
bool([0])输出___ .
True
[(0, 1), (1, 2)]
[0, 2, 3]
accddd
[3, 5, 7, 1, 2]
[[5], [5], [5]]
3
12
random 模块中 shuffle() 方法的作用是将列表中的元素随机乱序.
若string = “happy new year”，则string[3:-3] =___ .
py new y
已知 lst = [1,2,3,4,5], 则
• lst[:-1]= [1,2,3,4]. lst[::-1]= [5,4,3,2,1]
lst[1:3]= [2,3] .
• lst[:3]= [1,2,3] . lst[1:-1]= [2,3,4]. lst[::-2]= [5,3,1] .
• lst[-3:-1]= [3,4] . lst[:]= [1,2,3,4,5] . lst[::2]= [1,3,5] .
语句"Python Crash Courses".split()输出 .
['Python', 'Crash', 'Courses']
[1, 2, 3, 4, 5]
下列 while 循环执行的次数_10__ .
k = 1000
while k:
print(k) k //= 2
500
250
125
62
31
15
7
3
1
下列程序输出 .
num = 2
def change():
num = 3; print(num, end=’ ')
change() print(num)
3 2
2.75
{1: 3, 2: 4}
简要叙述列表和元组之间的区别，以及两者之间如何相互转换.
相同点：
都是序列
都可以存储任何数据类型
可以通过索引访问
不同点：
列表是可变的，而元组是不可变的，这标志着两者之间的关键差异。
元组无法复制。 原因是元组是不可变的。 如果运行tuple(tuple_name)将返回自己。
对于列表则分配小内存块。 与列表相比，元组的内存更小。
我们可以修改列表的值，但是不修改元组的值。
由于列表是可变的，我们不能将列表用作字典中的key。 但可以使用元组作为字典key。
摘自元组合列表
一般情况下
colors = ['红', '绿', '黄']
print(tuple(colors))
nums=(1,2,3)
print(list(nums))
输出
(‘红’, ‘绿’, ‘黄’)
[1, 2, 3]
摘自 Python 列表与元组之间，如何相互转换
2. 简要叙述 Python 中定义函数的规则.
1.创建名称具有可辨识性。
2.定义的函数参数也应该具有可辨识性。
3.形参可以设置默认参数。
4.必须按照正确的顺序输入参数，同时数量要与创建时的参数一致。
摘自百度经验
3. 简要叙述函数参数 *args, **kwargs 的意义.
首先，解释星号的作用，一个星号的作用是将tuple或者list中的元素进行unpack，分开传入，作为多个参数；两个星号**的作用是把dict类型的数据作为参数传入。
kwargs是keyword argument的缩写，args就是argument。我们知道，在Python中有两种参数，一种叫位置参数（positional argument），一种叫关键词参数（keyword argument），关键词参数只需要用 keyword = somekey 的方法即可传参，而位置参数只能由参数位置决定。这也就决定了位置参数一定要在前面，否则关键词参数数量的变化（比如有些kwargs有默认值因此没有传参或者在后面传参的），都会使得位置无法判断。因此常见的也是args 在 **kwargs 前面。
def this_fun(a,b,*args,**kwargs):
print a
print b
print args
print kwargs
this_fun(0,1,2,3,index1=11,index2=22)
0
1
(2, 3)
{'index2': 22, 'index1': 11}
摘自*arg和**kwargs区别
4. 简述面向对象中 new 和 init 区别.
init 通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性， 做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。
new 通常用于控制生成一个新实例的过程。它是类级别的方法,注意new一定需要返回值。
返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例
摘自_ inti and new__
5. 简要叙述可变与不可变对象的概念.
不可变对象：int，string，float，tuple
可变对象 ：list，dictionary
不可变对象： 由于Python中的变量存放的是对象引用，所以对于不可变对象而言，尽管对象本身不可变，但变量的对象引用是可变的。
可变对象：当对象的内容发生变化时，变量的对象引用是不会变化的。
摘自Python中的可变对象和不可变对象
6. 解释在 Python 中，实例方法 (instance method)，类方法 (class method) 与静态方法 (static method) 的区别.
普通实例方法，第一个参数需要是self，它表示一个具体的实例本身。
如果用了staticmethod，那么就可以无视这个self，而将这个方法当成一个普通的函数使用。
而对于classmethod，它的第一个参数不是self，是cls，它表示这个类本身。
class Foo(object):
"""类三种方法语法形式"""
def instance_method(self):
print("是类{}的实例方法，只能被实例对象调用".format(Foo))
@staticmethod
def static_method():
print("是静态方法")
@classmethod
def class_method(cls):
print("是类方法")
foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print('----------------')
Foo.static_method()
输出结果：
是类<class '__main__.Foo'>的实例方法，只能被实例对象调用
是静态方法
是类方法
----------------
是静态方法
是类方法
摘自python类的实例方法、静态方法和类方法区别及其应用场景
7. 将字符串s = “ajclcdjlabbjfdljbfdded”，去掉重复并从小到大排序输出.
s = "ajclcdjlabbjfdljbfdded"
s=list(set(s))
s.sort()
print(s)
输出结果：['a', 'b', 'c', 'd', 'e', 'f', 'j', 'l']
def is_odd(n):
return n % 2 == 1
print(list(filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])))
输出结果：[1, 3, 5, 7, 9]
dic={"name":"ymj","age":18,"city":"zhuhai","tel":"1590000"}
lis=sorted(dic.items(), key=lambda x: x[0], reverse=False)
dict_new = dict(lis)
print(dict_new)
输出结果：{'age': 18, 'city': 'zhuhai', 'name': 'ymj', 'tel': '1590000'}
按照名字排序：
foo = [{"name":"zs","age":19},
{"name":"ll","age":54},
{"name":"wa","age":17},
{"name":"df","age":23}]
foo=sorted(foo,key=lambda x : x["name"])
print(foo)
输出结果：[{'name': 'wa', 'age': 17}, {'name': 'zs', 'age': 19}, {'name': 'df', 'age': 23}, {'name': 'll', 'age': 54}]
根据年龄排序：
foo = [{"name":"zs","age":19},
{"name":"ll","age":54},
{"name":"wa","age":17},
{"name":"df","age":23}]
foo=sorted(foo,key=lambda x : x["age"])
print(foo)
输出结果：[{'name': 'wa', 'age': 17}, {'name': 'zs', 'age': 19}, {'name': 'df', 'age': 23}, {'name': 'll', 'age': 54}]
ymj=89
aaa=55
www=79
def grade(n):
if(n>=90):
return "A"
elif(n>=80 | n<=89):
return "B"
elif(n>=70 | n<=79):
return "C"
elif(n>=60 | n<=69):
return "D"
elif(n<60):
return "F"
else:
print("Wrong input!")
print(grade(ymj))
print(grade(aaa))
print(grade(www))
Out:
b
f
c
tmpStr = input('请输入字符串：')
alphaNum=0
numbers=0
spaceNum=0
otherNum=0
for i in tmpStr:
if i.isalpha():
alphaNum +=1
elif i.isnumeric():
numbers +=1
elif i.isspace():
spaceNum +=1
else:
otherNum +=1
print('字母=%d'%alphaNum)
print('数字=%d'%numbers)
print('空格=%d'%spaceNum)
print('其他=%d'%otherNum)
Out:
请输入字符串：asdqwrqwt asdagf 065
字母=15
数字=3
空格=2
其他=0
fp=open(r'D:\test.txt','a+')
print('helloworld',file=fp)
fp.close()
结果：
dic = {}
f = open('D:\\test.txt')
lis=f.readline().split()
for line in f.readlines():
line=line.split()
dic=dict(zip(lis,line))
print(dic)
f.close()
Out:
{'id': '1', 'name': 'Sam', 'age': '22', 'phone': '13651054608', 'job': 'IT'}
{'id': '2', 'name': 'Tom', 'age': '23', 'phone': '13304320533', 'job': 'Tearcher'}
{'id': '3', 'name': 'Jack', 'age': '18', 'phone': '1333235322', 'job': 'IT'}
定义一个学生类。有下面的类属性：
• 姓名
• 年龄
• 成绩 (一个列表，包含多门课程的成绩，都是整数)
类方法：
• 获取学生的姓名：get_name() 返回类型:str
• 获取学生的年龄：get_age() 返回类型:int
• 返回所有课程中的
class Student:
def __init__(self,name,age,grade):
self.name=name
self.age=age
self.grade=grade
def get_name(self):
return self.name
def get_age(self):
return self.age
def get_course(self):
return max(self.grade)
s=Student('ymj',20,[90,80,100])
print(s.get_name(),s.get_age(),s.get_course())
实验结果：`ymj 20 100`
本篇文章为本人的处女作，有的地方说不定不够严谨、可能有误，希望大家经供参考，有问题建议百度，问题解法不一定是最优。
