python基础题库100题及答案,python基础题目及答案

大家好，小编为大家解答python基础题库100题及答案的问题。很多人还不知道python基础题目及答案，现在让我们一起来看看吧！

测试基础-Python篇 基础①

变量名命名规则 - 遵循PEP8原则

• 普通变量：max_value

• 全局变量：MAX_VALUE

• 内部变量：_local_var

• 和关键字重名：class_

• 函数名：bar_function

• 类名：FooClass

• 布尔类型的变量名用 is,has 这类词语前缀
  is_superuser
  has_errors
  allow_empty

• 释义为数字的单词
  port
  age
  radius

• 以_id 为结尾的单词
  user_id
  port_id

• 以 length/count 开头或结尾的词
  length_of_username
  max_length
  users_count
  注：不要用名词的复数形式来作为 int 类型的变量名，因为名词的负数形式更像是一个容器。建议使用 number_of_apples 或 trips_count；

• 超短命名
  数组索引三剑客 i、j、k
  某个整数 n
  某个字符串 s
  某个异常 e
  文件对象 fp

变量注解

在Python3.5之后，可以使用类型注解功能来注明变量类型，在变量后添加类型，并用冒号隔开；

def repeat_message(message: str, count: int) -> str:
    return message * count

算术运算符

• // 取整除

• % 取余

• ** 幂

不同类型变量之间的计算

• 数字型变量之间可以直接计算；

• 如果变量是 bool 型，在计算时，true 对应的是1，false 对应的是0；

• 字符串变量之间使用 + 拼接字符串学c+之前要学python吗。

获取输入的信息-input

• 字符串变量 = input("提示信息")

input 输入的数据类型都是字符串类型

格式化输出

• %s --字符串

• %d --有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全

• %f --浮点数，%.2f 表示小数点后只显示两位，会四舍五入

• %% --输出%

vb1 = 'Tom'print("hello %s" % vb1)vb2 = 5print('有符号十进制整数：%d' % vb2)print('输出显示位数的整数：%06d' % vb2)vb3 = 3.1415926print('保留两位小数：%.2f' % vb3)print('保留三位小数：%.3f' % vb3)vb4 = 80print('正确率为：%d%%' % vb4)--------------------------------------------------------------------hello Tom有符号十进制整数：5输出显示位数的整数：000005保留两位小数：3.14保留三位小数：3.142正确率为：80%

逻辑运算

• and：
  条件1 and 条件2

• or：
  条件1 or 条件2

• not：（取反）
  not 条件

  a = 10b = 20c = 10if c == a and c == b:print('right')else:print('error')-------------------------------error

  a = 10b = 20c = 10if c == a or c == b:print('right')else:print('error')-------------------------------right

循环-while

初始条件设置 -- 通常是重复执行的 计数器
while 条件 1:
条件满足时，做的事情 1
条件满足时，做的事情 2
条件满足时，做的事情 3
……
while 条件 2:
条件满足时，做的事情 1
条件满足时，做的事情 2
条件满足时，做的事情 3
……
处理条件 2
处理条件 1

print 函数增强

在默认情况下，print 函数输出内容之后，会自动在内容末尾增加换行；
如果不希望末尾增加换行，可以在 peint 函数输出内容的后面增加,end=""
其中""中间可以指定 print 函数输出内容之后，继续希望现实的内容；
语法格式如下：
print("*",end="")

转义字符

• \t--在控制台输出一个制表符，协助在输出文本时，垂直方向，保持对齐

• \n--在控制台输出一个换行符

• \r--回车

• \--反斜杠符号

• \'--单引号

• \"--双引号

列表

• 列表通过索引取值，列表索引从0开始，且不能超过范围；

• len(列表)--获取列表的长度

• 列表.count(数据)--数据在列表中出现的次数

• 列表.index(数据)--获取数据第一次出现的索引

• del 列表 [索引]--删除指定索引的数据

• 列表.remove[数据]--删除第一个出现的指定数据

• 列表.pop--删除末尾数据

• 列表.pop(索引)--删除指定索引的数据

• 列表.insert(索引,数据)--在指定位置插入数据

• 列表.append(数据)--在末尾追加数据

• 列表.extend(列表 2)--将列表2的数据追加到列表1

• 列表.sort()--升序排序

• 列表.sort(reverse=True)--降序排序

• 列表.reverse() 反转/逆序

元祖

• Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改；

• 创建空元组：info_tuple = ()

• 元组中只包含一个元素时，需要在元素后面添加逗号：info_tuple = (50, )

• len(元组)--获取元组的长度 n+1；

• 元组.count(数据)--数据在元组中出现的次数；

• 元组 [索引]--从元祖中取值；

• 元组.index(数据)--获取数据第一次出现的索引。

元组和列表之间的转换

• 使用 list 函数可以把元组转换成列表
  list(元组)

• 使用 tuple 函数可以把列表转换成元组
  tuple(列表)

字典

• Python 里的字典在底层使用了哈希表 (hash table) 数据结构

• 和列表的区别：列表 是 有序 的对象集合 字典 是 无序 的对象集合

Python3.6 之后的字典是有序的，如果解释器版本没有那么新，也可以使用 collections 模块里的 OrderedDict 方法保证字典的有序性。
OrderedDict 与新版字典在比较上面的区别：在对比两个内容相同但顺序不同的字典时，新版字典会返回 True，OrderedDict 则会返回 False。

    from collections import OrderedDict
    d = OrderedDict()
    d['one'] = 1
    d['two'] = 2
    print(d)————————————————————
    OrderedDict([('one', 1), ('two', 2)])

• 键必须是唯一的；

• 值可以取任何数据类型，但键只能使用字符串、数字或元组；

• 字典.keys()--所有 key 列表；

• 字典.values()--所有 value 列表；

• 字典.items()--所有（key，value）元组列表；

• 字典 [key]--可以从字典中取值，key 不存在会报错；
  1.返回的数据类型类似列表，但不是真正意义的列表，没有 append() 方法;
  2.但是可以用于 for 循环;
  3.可以用 list() 方转换成真正的列表;

• 字典.get(key)--可以从字典中取值，key 不存在不会报错；

• del 字典 [key]--删除指定键值对，key 不存在会报错；

• 字典.pop(key)--删除指定键值对，并且返回删除键对应的值，key 不存在会报错；

• 字典.pop(key, default=msg)--删除指定键值对，并且返回删除键对应的值，key 不存在不会报错，会返回 msg；

• 字典 popitem() 方法返回并删除字典中的最后一对键和值。

• 字典.clear()--清空字典；

• 字典 [key] = value
  如果 key 存在，修改数据
  如果 key 不存在，新建键值对

• 字典.setdefault(key,value)
  如果 key 存在，不会修改数据
  如果 key 不存在，新建键值对

• 字典.update(字典2)--将字典2的数据合并到字典1，如果字典2中有和字典 1 重复的键值对，则替换字典 1 中的键值对；

• 生成字典的方法：d = dict.fromkeys(["name","age","code"],0) #0 为默认值

字符串

• 拼接多个字符串，使用 str.join 和 +=同样好用；

• len(字符串)--获取字符串的长度；

• 字符串.count(字符串)--小字符串在大字符串中出现的次数；

• 字符串 [索引]--从字符串中取出单个字符；

• 字符串.index(字符串)--获得小字符串第一次出现的索引；

• string.istitle() | 如果 string 是标题化的 (每个单词的首字母大写) 则返回 True；

• string.startswith(str) | 检查字符串是否是以 str 开头，是则返回 True；

• string.endswith(str) | 检查字符串是否是以 str 结束，是则返回 True；

• string.find(str, start=0, end=len(string)) | 检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1 ；

• string.index(str, start=0, end=len(string)) | 跟 find() 方法类似，不过如果 str 不在 string 会报错；

• string.replace(old_str, new_str, num=string.count(old)) | 把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次；

• string.capitalize() | 把字符串的第一个字符大写；

• string.title() | 把字符串的每个单词首字母大写；

• string.lower() | 转换 string 中所有大写字符为小写；

• string.upper() | 转换 string 中的小写字母为大写；

• string.swapcase() | 翻转 string 中的大小写；

字符串 - 切片

• 切片方法适用于字符串、列表、元组；

• 字符串 [开始索引:结束索引:步长]；

• 切片：正反向索引（正:从 0 开始，反:从-1 开始）

• 切片索引：[startENDstep]

• start:开始截取的位置，包含在截取内容内

• end:结束截取的位置，结束截取的位置并不包含

• step:截取的步长，默认值为 1

• step:为正，表示从左到右进行截取，start 必须在 end 之前（从左开始算前，下标必须从左到右）

• step:为负，表示从右到左进行截取，start 必须在 end 之前（从右开始算前，下标必须从右到左）

• s = "hello,world"
  print(s[:]) # 取全部
  print(s[1:]) # 从第 2 位取到最后
  print(s[:-1]) # 从开始取到倒数第二位
  print(s[::2]) # 步长为 2
  print(s[::-1]) # 反序

指定的区间属于左闭右开型 [开始索引, 结束索引) => 开始索引 >= 范围 < 结束索引
从 起始位开始，到 结束位的前一位 结束（不包含结束位本身)
从头开始，开始索引 数字可以省略，冒号不能省略
到末尾结束，结束索引 数字可以省略，冒号不能省略
步长默认为 1，如果连续切片，数字和冒号都可以省略
索引的顺序和倒序：
在 Python 中不仅支持 顺序索引，同时还支持 倒序索引
所谓倒序索引就是 从右向左 计算索引
最右边的索引值是 -1，依次递减

字符串格式化

• 优先使用 f-string 方式

# 将username靠右对齐，左侧补空格一共到20位username = 'Lili'print(f'{
    username:>20}')-------------------------------------
                Lili

• 对参数复用时可以使用 str.format 方式

username = 'Lily'sore = 10print('{0}:{0}的成绩是{1}'.format(username, sore))

集合

• 集合是一个无序的可变容器类型，他最大的特点就是成员不能重复

• 要初始化一个空集合只能调用 set() 方法，因为{}表示的是一个空字典，而不是一个空集合

• 集合也有自己的推导式-nums = {n for n in range(10) if n % 2 == 0}

• 集合是可变类型，可以通过.add() 追加元素

• 可以使用 update 方法可以将一个可迭代元素更新到集合中

s1 = set([1,2,3])s2 = set([2,3,4])s1.update(s2)s1.update('hello')print(s1)------------------------{1, 2, 3, 4, 'o', 'h', 'e', 'l'}

• 使用.remove() 可以删除集合中的元素，但元素不存在会报错-KeyError:

• 使用.discard() 可以删除集合中的元素，元素不存在也不会报错

• 集合的元素不可以修改，只能先删再加

• 我们可以使用 in 判断某个元素是否在某个集合中，不能在集合中取值，只能使用 for 循环遍历集合中的元素

• 集合只能存放可哈希对象

s1 = set([1,2,3])s1.add([1])-----------------------TypeError: unhashable type: 'list'

集合的运算

集合支持集合运算，比如交集、并集、差集。所有的操作都可以用两种方式：方法和运算符；

• 交集

fruits_1 = {'apple','orange','pineapple'}fruits_2 = {'tomato','orange','grapes','mango'}print(fruits_1 & fruits_2)-----------------------------{'orange'}

• 并集

fruits_1 = {'apple','orange','pineapple'}fruits_2 = {'tomato','orange','grapes','mango'}print(fruits_1 | fruits_2)----------------------------------------------------------{'tomato', 'pineapple', 'orange', 'apple', 'grapes', 'mango'}

• 差集（前有后没有）

fruits_1 = {'apple','orange','pineapple'}fruits_2 = {'tomato','orange','grapes','mango'}print(fruits_1 - fruits_2)------------------------------------{'apple', 'pineapple'}

• symmetric_difference：返回两个集合中不重复的元素

fruits_1 = {'apple','orange','pineapple'}fruits_2 = {'tomato','orange','grapes','mango'}print(fruits_1.symmetric_difference(fruits_2)){'apple', 'mango', 'tomato', 'pineapple', 'grapes'}

• issubset：用于判断集合的所有元素是否都包含在指定集合中

fruits_1 = {'apple','orange','pineapple'}fruits_2 = {'apple','orange','pineapple','water'}print(fruits_1.issubset(fruits_2))print(fruits_2.issubset(fruits_1))--------------------------------------------------TrueFalse

Python 循环结构

• 什么时候用 for：当循环次数是一定的，或者是循环对象是一定的，比如说在一个固定的字符串或列表中进行循环，那么最好使用 for

• 什么时候用 while：当循环次数不是一定的，只是满足某个条件时才进行循环，那么最好使用 while

• 没有 do…while…循环

• 循环里面加 else：当循环执行完毕时，else 才会执行；如果循环在中间退出，则 else 不会运行

• break&continue：不管是 break 还是 continue 都只作用于当前循环

匿名函数-lambda

• lambda 关键字能够帮我们创建小型的匿名函数：

• lambda x:express

• lambda 返回的是该匿名函数的指针

• func = lambda x,y:x*y
  print(func(2,3))

类

类定义

• 类名首字母大写，多个字母连接一起

• 默认继承 object 类，若继承其他类则在类名后加（继承父类）

类方法

• 实例方法
  1、只能通过对象 (实例) 调用的方法
  2、实例方法在定义时总是以 self 作为第一个参数
  3、实例方法在调用时不需要传入 self，这个实例本身会自动传到方法中作为 self

• 初始化方法 (init())
  1.不需要显式调用，在初始化对象时会有 python 自动调用
  2.初始化方法一般只在定义对象属性的时候才会定义

• 类方法
  1、可以直接通过类名调用的方法，也可以通过实例调用
  2、类方法必须通过@classmethod装饰器进行装饰
  3、所有的类方法第一个参数必须是 cls
  4、类方法不能访问实例属性，只能访问类属性

• 属性方法
  使用场景：属性方法对应的属性的值无法直接确定，要通过一系列的操作才能得到这个值，而且用户不关心这个操作过程，只想得到这个值。
  定义：当成属性使用的方法，调用属性方法时不需要加 ()

• 静态方法
  1、通过@staticmethod装饰器来进行装饰的方法
  2、静态方法既不能访问实例属性，也不能访问类属性
  3、可以通过类名直接调用，也可以通过对象调用

类的三大特征

• 封装
  暴露接口，隐藏细节

• 继承
  1.子类通过继承直接获得父类的全部属性和方法，实现代码复用
  2.初始化的几种情况：
  2.1 当子类中没有定义init() 方法，则初始化子类时将默认使用父类的初始化方法，并传入对应的参数
  2.2 当子类定义了自己的初始化方法，但没有调用父类的初始化方法，则父类中的相关属性不会被初始化
  2.3 若在子类中重新定义了 init 方法，若仍要继承父类的属性，则需要显示调用父类的 init 方法：super().init()

• 多态

类的反射

• 反射原理
  通过字符串的形式在运行时动态修改程序的变量、方法及属性，所有的修改都在内存中进行，所以他并不会实际修改代码，主要目的就是提高代码在运行时的灵活性；

• 反射相关的方法
  hasattr 输入一个字符串，判断对象有没有这个方法或属性；
  getattr 获取对象属性值或方法的引用，如果是方法，则返回方法的引用，如果是属性，则返回属性的值，如果该方法或属性不存在，则抛出异常；
  setattr 动态添加一个方法或属性；
  delattr 动态删除一个方法或属性。

异常处理

Python 异常处理依赖的关键字：
try
except
else
finally

• try
  try 块里面放置所有可能引起异常的代码，一个异常处理块里面只能有一个 try；

• except
  放置要处理的异常类型和相应语句块，用于表明该 except 要处理的异常类型；
  一个异常处理块里面可以跟 1 到 n 个 except 块；
  每个 except 块后面可以跟 1 到 n 个异常类型，也可以不跟任何异常类型；

• else
  如果 try 块里面的语句没有引起异常，则会运行 else