python中什么是pep_python技术应用认证证书有用吗

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

前言：
进入python institue官网查看认证内容和考试：

购买考试凭据：

PCEP的政策：

PCEP的考试大纲：

Python作为目前业界最受欢迎的语言，是大部分数据分析相关从业人员的一项必备技能。对于很多0基础的小白，经常会问的问题就是，如何快速学习Python。在这里给大家介绍一个Python入门级的考试：PCEP-30-01 Exam。

证书介绍

PCEP-30-01是Python Institute资格认证的初级程序员考试，考试的全称是：PCEP Certified Entry-Level Python Programmer

这个考试并不需要有任何基础，是最入门级别的考试，对于从事数据分析的小伙伴们，这门考试只是一个入门，在考完这个考试的基础上，还可以参加Python Institute的另外两个考试：

PCAP – Certified Associate in Python Programming：中级PCAP证书
PCPP1 -Certified Professional in Python Programming 1：高级PCPP1证书

考试基本情况

• 考试在自己电脑进行，无监考
• 考试前需购买Voucher，Voucher有效期为至少六个月
• 考试费用：$59刀
• 45分钟的考试时间，外加大约5分钟的保密协议签订
• 考试正式开始前，要保证自己电脑的自动更新、电脑提示等功能关闭
• 考试问题数量：30题
• 题目形式：选择题以及填空题。通过分数：70%即可通过
• 考试提交答案后大约一分钟即可知道自己是否通过，通过的话会收到相应的证书

考试准备材料

对于这门考试的准备，强烈推荐Python Essentials-Partl (Basics)这门课程，课程是完全免费的，并且可以按照自己的进度进行学习。

课程链接：https://edube.org/study/pe1

课程的学习时间大约为42h，推荐每周学习7h。

课程一共分为四个模块，每个模块结束之后都会有针对这个模块的Quizz和Test，四个模块都学完之后，会有一个综合的Test。

Quizz结束后可以看到正确答案，但是Test结束后不会知道自己的错题是哪道（无法知道正确答案)。

Test难度与真实考试接近，但是注意Test考试中没有任何填空题，全部为选择题，真实考试中是有填空题的。

由于这个证书是这系列证书里最基本的，所以不需要参加考试的人有任何编程经验。对于像寿司一样，自己是有一定的编程基础+Python经验的人来说，也建议大家在考试之前，一定要快速学习浏览一下课程的内容。考试的很多内容都涉及了基础概念，即使经常写程序的人，也很容易有不熟悉的部分。

备考大纲

前言：按照2022年5月的python institue官网发布的最新的考试大纲进行梳理

阅读说明：黑点 – 是考点，>是解读，#python institue test题是官网教程中test部分的考题。

*Section 1：Computer Programming and Python Fundamentals(18%)*第一节:计算机编程和Python基础

Objectives covered by the block (7 exam items)模块涵盖的目标(7个考试项目)

PCEP-30-02 1.1 – Understand fundamental terms and definitions理解基本术语和定义（18%）

interpreting and the interpreter, compilation and the compiler解释和解释器，编译和编译器

python institue test：解释器interpreter是一条一条的解释执行源语言，解释器是一种计算机程序，它直接执行由编程语言或脚本语言编写的代码，并不会把源代码预编译成机器码。比如php，postscritp，javascript就是典型的解释性语言。　　
编译器compiler是把源代码整个编译成目标代码，执行时不在需要编译器，直接在支持目标代码的平台上运行，这样执行效率比解释执行快很多。比如C语言代码被编译成二进制代码（exe程序），在windows平台上执行。

lexis, syntax, and semantics词汇、语法和语义

python institue test：构成语言的四大基本要素：an alphabet，a lexis，a syntax，and semantics字母表、词汇、语法和语义

PCEP-30-02 1.2 – Understand Python’s logic and structure理解Python的逻辑和结构

keywords关键字

instructions说明

indentation

comments：#是Python里的注释

PCEP-30-02 1.3 – Introduce literals and variables into code and use different numeral systems在代码中引入文字和变量，并使用不同的数字系统

Boolean, integers, floating-point numbers：/(除以）的结果永远是浮点数，注意与//(double slash）结果的区别

” / “就表示 浮点数除法，返回浮点结果;” // “表示整数除法。
python Institue test：integer and floating-point之间最重要的区别在于：they are stored differently in the computer memory

scientific notation科学记数法

科学计数法：10^x次方，用e来表示

#python insitute test题如下：
x = 1e+3    #+加号指10次方
x1 = 1e-3  #-减号是指0.1次方
x2 = 1e+03
x3 = 1e+003
x4 = 1E+3    #e不分大小写
print(x)
print(x1)
print(x2)
print(x3)
print(x4)
执行结果如下：
1000.0
0.001
1000.0
1000.0
1000.0

strings

binary, octal, decimal, and hexadecimal numeral systems二进制，八进制，十进制和十六进制数字系统

numeral systems数制：这部分相对来说是大部分人可能容易忽略的基础知识，注意八进制，十六进制的表达方法，以及decimal十进制和binary二进制之间互相的转换

二进制（Binary），八进制（Octal），十进制（Decimal），十六进制（Hexadecimal）
八进制，十六进制的表达方法：
1.八进制数是一种逢八进一的计数体制,基数是8,用0~7表示,如077。
2.八进制数以数字0开头。
3.十六进制数是一种逢十六进一的计数体制,基数是16,用0_9,AF表示,如0xFF或0XFF。
4.十六进制数以数字0和字母x的组合0x或0X开头。其中字母x是不区分大小写的,即0x与0X等价。
python institue test：八进制Octal简写是O，十六进制Hexadecimal简写是0x

decimal十进制和binary二进制之间互相的转换：
二进制变十进制转换原则：把二进制数写成按权展开的多项式加法，然后求和，即可将二进制转化为十进制数。

十进制变为二进制：1.整数部分转换原则：除2取余法，将所得余数倒着写。即将十进制数反复除以2，取余数，直到商为0为止，最后将所得余数倒着排列，即为十进制数转换为二进制数。

variables变量

naming conventions命名规范

implementing PEP-8 recommendations实现PEP-8建议

PCEP-30-02 1.4 – Choose operators and data types adequate to the problem选择适合问题的操作符和数据类型

numeric operators: ** * / % // + –：数值返回运算符，考前一定要熟悉运算符号的优先顺序，比如&的优先级高于|

以下表格的算数优先级由高到最低顺序排列

优先级高到低	类型	运算符	描述	内部优先级
1	算数运算符	**	幂（最高优先级）	运算从左到右(幂＞乘除取余数整数＞加减)
2	算数运算符	*、/、%、//	乘、除、取余数、取整数	运算从左到右(幂＞乘除取余数整数＞加减)
3	算数运算符	+、-	加法、减法	运算从左到右(幂＞乘除取余数整数＞加减)
4	比较运算符	＜=、＜、＞、＞=	比较	运算从左到右
5	等于运算符	==、！=	等于不等于	运算从左到右
6	赋值运算符	=、%=、/=、//=、-=、+=、*=	赋值	运算从左到右
7	逻辑运算符	not、and 、or	不、或、和	() > not > and > or

记忆：双臂等腹肌
难点1：逻辑运算是最低的，而且之间还是优先级，not，and，or不合伙

#python institue test:

难点2：运算，从右到左，如 12**3=1

#python institue test:
a = 1 ** 2 ** 3
print(a)
b = 2 ** 2 ** 3
print(b)
执行结果如下：
1
256

易错：/是除，//比/多/是整除，%长得就奇怪，那就是取余数了；/是除，得到若是整数是X.0

#python insitute test题如下：
x = int(input())
y = int(input())
x = x % y   #%与//易混，%取余数，//取整除，x=3%2=1
x = x % y   #x=0%2=0
y = y % x
print(y)
执行结果如下：
3   #人为输入的，不是输出结果
2   #人为输入的，不是输出结果
0

#python insitute test题如下：
x = 1 // 5 + 1 / 5
print(x)
执行结果如下：
0.2

#python insitute test题如下：
x = int(input())
y = int(input())
x = x % y
x = x % y            #3除以4，商0，余3
y = y % x            #4除以3，余1
print(y)
执行结果如下：
11  #人为输入
4   #人为输入
1

#python insitute test题如下：
x = int(input())
y = int(input())
x = x // y
y = y // x
print(y)
执行结果如下：
2  #人为输入
4   #人为输入
    y = y // x
ZeroDivisionError: integer division or modulo by zero

#python insitute test题如下：
x = int(input())
y = int(input())
x = x / y
y = y / x
print(y)
执行结果如下：
2  #人为输入
4   #人为输入
8.0

#python insitute test题如下：
x = 1 / 1
print(x)
执行结果如下：
1.0

#python insitute test题如下：
y = 2 + 3 * 5.
print(y)
执行结果如下：
17.0

#python insitute test题如下：
y = 2 + 3 * 5.
print(Y)
执行结果如下：
    print(Y)
NameError: name 'Y' is not defined

string operators: * +字符串运算符

#python insitute test题如下：
x = input()
y = input()
print(x + y)
执行结果如下：
2   #人为输入
4   #人为输入
24

assignment and shortcut operators赋值和快捷操作符

unary and binary operators：操作符：一元和二元，优先级和绑定：注意exponential operator指数运算符用的是right-sided binding右侧绑定，也就是从右至左的顺序

priorities and binding优先级和绑定

bitwise operators: ~ & ^ | << >>逐位运算符：~&^|<<>>：按位运算符号，注意按位运算是按照参与的数据进行二进制位表达之后的运算

按位运算符	描述	原理	简单的例子	运算过程
&	按位与运算符	如果两个位均为1，Python按位运算符将返回1，否则返回0	10＆7 = 2	10二进制为1010，7二进制为111,1010&0111=0010十进制为2
\	按位或运算符	如果任何位为1，Python按位或运算符将返回1。如果两个位均为0，则它​​将返回0	10 /7 = 15	1010/0111=1111十进制为15
^	按位XOR运算符	如果一位为0，另一位为1，则Python按位XOR运算符将返回1。如果两个位均为0或1，则它将返回0。	10 ^ 7 = 13	1010 ^ 0111=1101十进制为13
〜	按位补码运算符	数字’A’的补码等于-（A + 1）	〜10 = -11	10=1010=-(1010+1)=-1011十进制为-11
<<	按位左移运算符	将右操作数中的给定次数向左移动左操作数位。 简而言之，二进制数末尾带有0	10 << 2 = 40	10 << 2 = 1010 << 2 = 101000十进制40
>>	按位右移运算符	将左侧操作数位向右侧移动给定次数。 简单来说，右侧位已删除	10 >> 1 = 5	10 >> 1 =1010 >> 1 = 10 =2

记忆：&等同于and，\等同于或，^等于不或，即不是或的都为0，<<末尾多0，>>删掉右侧位

#python insitute test题如下：
a = 1
b = 0
a = a ^ b   #0001 ^ 0000 =0001十进制为1
b = a ^ b   #0001 ^ 0000 =0001十进制为1
a = a ^ b   #0001 ^ 0001 =0000十进制为0
print(a,b)
执行结果如下：
0 1

#python insitute test题如下：
a = 1
b = 0
c = a & b   #0001 & 0000 = 0000十进制为0
d = a | b   #0001 | 0000 = 0001十进制为1
e = a ^ b   #0001 ^ 0000 = 0001十进制为1
print(c + d + e)
执行结果如下：
2

#python insitute test题如下：
var = 1
while var < 10:
    print("#")
    var = var << 1 # 0001 << 1，得：00010；依次类推，000100,0001000,00010000＞10
执行结果如下：
#
#
#
#

Boolean operators: not, and, or布尔操作符:not, and, or

Boolean expressions布尔表达式

relational operators ( == != > >= < <= )：关系运算符，考察重点是==与=的区别，前者是比较两个数值大小，后者是赋值。另外也要注意几个运算的优先级

the accuracy of floating-point numbers浮点数的精确性

type casting类型转换

PCEP-30-02 1.5 – Perform Input/Output console operations

the print() and input() functions：注意input function出来的数据是string字符串形式，如果要转换结果的类别，需要在前面加入相应的int(), float()等

input函数实现键盘输入
●在Python中可以使用input 函数从键盘等待用户的输入
●用户输入的任何内容Python都认为是一个字符串

python institue test：the print() function can output values of any number of argurments (including zero)

#python insitute test题如下：
y = input()
x = input()
print(x + y)
执行结果如下：
3   #需人为输入
6   #需人为输入
63

#python insitute test题如下：
x = input()
y = int(input())
print(x * y)
执行结果如下：
3   #需人为输入
6   #需人为输入
333333

the sep= and end= keyword parameters：注意sep,end的用法：

print函数的作用是打印输出内容，它的sep和end参数可以让我们的打印更具有个性化。
seq：用来间隔多个对象，默认值是一个空格。也可以输入特定的值（符号、数字、中文都可）来间隔内容。
end：用来设定以什么结尾，默认值是换行符”\n”。也可以输入其他值来结尾。

#python insitute test题如下：
print("a","b","c",sep="sep")  #seq：用来间隔多个对象，默认值是一个空格。也可以输入特定的值（符号、数字、中文都可）来间隔内容。
执行结果如下：
asepbsepc

#python insitute test题如下：
def any():
    print(var + 1, end='')  #end：用来设定以什么结尾，默认值是换行符"\n"。也可以输入其他值来结尾。
var = 1
any()
print(var)
执行结果如下：
21
补充说明：
def any():
    print(var + 1)   #去掉end=''，证明其作用
var = 1
any()
print(var)
执行结果如下：
2
1

the int() and float() functions

python Institue test：

*Section2：Flow Control- Loops and Conditional Blocks（29%）*流控制-循环和条件块

Objectives covered by the block (8 exam items)

PCEP-30-02 2.1 – Make decisions and branch the flow with the if instruction使用if指令做出决策并对流进行分支

conditional statements条件语句：if, if-else, if-elif, if-elif-else：考试重点，对于给定的if相关语句，能够知道最后结果是什么。注意break和continue在loops中间的作用：break即刻中止循环，而continue将会开启新一轮的conditional expression test条件表达式的测试

if, if-else, if-elif, if-elif-else：

If

if 判断条件:
    判断条件为 True,会执行的代码
    判断条件为 True,会执行的代码
    ...

顶格书写的代码,代表和 if 判断没有关系
在 python 中使用缩进,代替代码的层级关系, 在 if 语句的缩进内,属于 if 语句的代码块(多行代码的意思)

If else

if 判断条件:
    判断条件为 True,会执行的代码
    判断条件为 True,会执行的代码
    ...
else:
    判断条件为 False, 会执行的代码
    判断条件为 False, 会执行的代码
    .....
    
if 和 else 只会执行其中的一个 

if elif else

if 	判断条件1:
    判断条件1成立,执行的代码
elif 判断条件2:
    判断条件1不成立,判断条件2 成立,会执行的代码
else:
    判断条件1和判断条件2都不成立,执行的代码

#python insitute test题如下：
i = 0
while i < i + 2 :
    i += 1        #while条件永远成立，结果会出现无数个*
    print ("*")
else:             #if 和 else 只会执行其中的一个 
    print ("*")

#python insitute test题如下：
def fun (x) :
    if x % 2== 0 :
        return 1
    else:
        return 2
print (fun (fun(2)))  #fun(2)时，返回1；fun(1)时，返回2

执行结果如下：
2

#python insitute test题如下：
def fun(x, y):
    if x == y:
        return x
    else:
        return fun(x, y-1)    #if条件不满足，执行else，返回fun(0,2)，继续循环，当fun(0,0)时，x=y,返回0
print (fun(0,3))
执行结果如下：
0

#python insitute test题如下：
for i in range(1):
    print("#")
else:
    print("#")
执行结果如下：   #不理解
#
#

类似：
for i in range(2):
    print("#")
else:
    print("#")
执行结果如下：
#
#
#

multiple conditional statements多个条件语句：主要考察应用，对于给定statements语句，能够知道最终结果是什么

nesting conditional statements嵌套条件语句

PCEP-30-02 2.2 – Perform different types of iterations执行不同类型的迭代

the pass instruction：考试大纲里有，但是实际没有考察到

building loops：while, for, range(),in：考察重点，尤其注意range()里最后一个数字是不包括的，比如range (9)指的是0-8，不包括9

for 变量 in 字符串：变量一次循环是字符串中的一个字符；
range(n) 会生成 [0, n) 的数据序列, 不包含n；
range(a, b) 会生成 [a, b) 的整数序列, 不包含b；a和b需要从小到大排序，否则无法输出；
range(a, b, step) 会生成[a, b) 的整数序列,但是每个数字之间的间隔(步长)是step；

iterating through sequences遍历序列：侧重考察是否能读取正确结果

#python insitute test题如下：
for i in range(-1,1):
    print("#")
执行结果如下：
#
#

expanding loops with while-else,for-else：侧重考察是否能读取正确结果

while-else：
for-else：

nesting loops and conditional statements：嵌套循环和条件语句，侧重考察是否能读取正确结果

controlling loop execution：break,continue：控制循环执行，如前所述，break和continue是考察的重点

一、break和continue的作用
break和continue都是用来控制循环结构的，主要作用是停止循环。
二、break和continue的区别
1、break用于跳出一个循环体或者完全结束一个循环，不仅可以结束其所在的循环，还可结束其外层循环。
注意：
（1）只能在循环体内和switch语句体内使用break。
（2）不管是哪种循环，一旦在循环体中遇到break，系统将完全结束循环，开始执行循环之后的代码。
（3）当break出现在循环体中的switch语句体内时，起作用只是跳出该switch语句体，并不能终止循环体的执行。若想强行终止循环体的执行，可以在循环体中，但并不在switch语句中设置break语句，满足某种条件则跳出本层循环体。
2、continue语句的作用是跳过本次循环体中剩下尚未执行的语句，立即进行下一次的循环条件判定，可以理解为只是中止(跳过)本次循环，接着开始下一次循环。
注意：
（1）continue语句并没有使整个循环终止。
（2）continue 只能在循环语句中使用，即只能在 for、while 和 do…while 语句中使用。

#python insitute test题如下：
i = 0
while i <= 5 :
    i += 1
    if i % 2 == 0:
        break     #break用于跳出一个循环体或者完全结束一个循环，不仅可以结束其所在的循环，还可结束其外层循环。
    print("*")
    执行结果如下：
*

#python insitute test题如下：
var = 0
while var < 6:
    var += 1
    if var % 2 == 0:
        continue
    print("#")
执行结果如下：
#
#
#

*Section3：Data Collections -Lists,Tuples,and Dictionaries(25%)*数据集合-列表，元组和字典

Objectives covered by the block (7 exam items)

PCEP-30-02 3.1 – Collect and process data using lists

constructing vectors从向量构建矩阵

indexing and slicing索引和切片

重点考察slicing切片。注意当选取List2=List1时候，复制的是名字，而不是内容；与之不同，slicing复制的是内容，而不是名字。当复制的是名字的时候，他们将指向computer memory里的同一位置，所以改变其中一个会改变另外一个。

#python insitute test题如下：
nums = []
vals = nums      #当复制的是名字的时候，他们将指向computer memory里的同一位置，所以改变其中一个会改变另外一个
print(vals)
print(nums)
vals.append(1)
print(vals)
print(nums)
输出结果：
[]
[]
[1]
[1]

#python insitute test题如下：
nums = []
vals = nums[:]     #slicing复制的是内容，而不是名字
print(vals)
print(nums)
vals.append(1)
print(vals)
print(nums)
执行结果如下：
[]
[]
[1]
[]

#python insitute test题如下：
nums = [1, 2, 3]
vals = nums      #当复制的是名字的时候，他们将指向computer memory里的同一位置，所以改变其中一个会改变另外一个
del vals[1:2]   #指定的区间属于 左闭右开 型 ，[1,2)，即删掉vals下标1的元素
print(vals)
print(nums)
执行结果如下：
[1, 3]
[1, 3]

#python insitute test题如下：
vals = [0, 1, 2]
vals[0], vals[2] = vals[2], vals[0]   #反转列表
print(vals)
执行结果如下：
[2, 1, 0]

1.对切片赋值，相当于替代原list中的切片部分，赋值的list不必与切片长度一致，也可以将切片赋值给新的变量，用以取原list中的一部分；
2.list中的元素在切片中可以用正数索引或负数索引表示，正向索引为0,1,2……，第一个元素索引为0；负向索引-1，-2，-3，……最后一个元素索引-1；
3.可以指定间隔进行切片。
4.语法形式是a[start:end]，这里有一个区间边沿取值的问题。首先你要明确序列的索引是从0开始的，a[2:5]取值的范围是[2,5)，前面是闭区间，后面是开区间，也就是2<=索引值<5这段区间里的元素。所以如果这样来切的话：a[1:1]，得到的就是[]，空序列。

#python insitute test题如下：
my_list = [3, 1, -1]
my_list[-1] = my_list[-2]
print(my_list)
输出结果：
[3, 1, 1]

#python insitute test题如下：
my_list = [1, 2, 3, 4]
print(my_list[-3:-2])   #语法形式是a[start:end]，这里有一个区间边沿取值的问题。首先你要明确序列的索引是从0开始的，a[2:5]取值的范围是[2,5)，前面是闭区间，后面是开区间，也就是2<=索引值<5这段区间里的元素。所以如果这样来切的话：a[1:1]，得到的就是[]，空序列。
执行结果如下：
[2]

the len() function

#python insitute test题如下：
my_list = [1, 2, 3]
for v in range(len(my_list)):
    my_list.insert(1,my_list[v])
print(my_list)
执行结果如下：
[1, 1, 1, 1, 2, 3]

list methods: append(), insert(), index(), etc.

考察重点是append和insert的methods方法，for循环

append方法用来在末尾插入新元素；insert方法则可以在指定位置插入新元素

#python insitute test题如下：
my_list = [1, 2, 3]
for v in range(len(my_list)):  #len(my_list)=3，v=0,1,2
    my_list.insert(1,my_list[v]) #当v=0时，my_list[0]=1，my_list因insert插入1，my_list=[1,1,2,3]；当v=1时,my_list[1]=1，insert进行插入，my_list=[1,1,1,2,3]
print(my_list)
执行结果如下：
[1, 1, 1, 1, 2, 3]

#python insitute test题如下：
my_list = [1,2]       #列表指定的区间属于左闭右开型 [开始索引,结束索引) => 开始索引 >= 范围 < 结束索引；从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
for v in range(2):     #range(n) 会生成 [0, n) 的数据序列, 不包含n，得v=0,1
    my_list.insert(-1, my_list[v])    #name_list.insert(下标, 数据)，位置被插入的元素，顺延下标加1,下标-1表示最后一个数据，依次向前类推。因为for语句，v=0时，my_list[0]=1，再结合insert语句，此时my_list=[1,1,2]，v=1时，my_list[1]=1，再结合insert语句，此时my_list=[1,1,1,2]
print(my_list)
执行结果如下：
[1, 1, 1, 2]

#python insitute test题如下：
my_list_1 = [1, 2, 3]
my_list_2 = []
for v in my_list_1:
    my_list_2.insert(0,v)
print(my_list_2)
执行结果如下：
[3, 2, 1]

补充说明：
my_list_1 = [1, 2, 3]
for v in my_list_1:
    print(v)
执行结果如下：
1
2
3

#python insitute test题如下：
vals = [0, 1, 2]
vals.insert(0,1)     #name_list.insert(下标, 数据)，位置被插入的元素，顺延下标加1
print(vals)
del vals[1]
print(vals)
执行结果如下：
[1, 0, 1, 2]
[1, 1, 2]

functions: len(), sorted()

the del instruction

#python insitute test题如下：
nums=[1,2,3]
vals = nums
del vals[0]
print(nums)    #输入结果证明列表是动态数组，等于赋值后，改变一个会改变另一个
print(vals)
执行结果如下：
[2,3]
[2,3]

#python insitute test题如下：
my_list =[x * x for x in range (5)]  #rang(5)=0,1,2,3,4，x*x=0,1,4,9,16
def fun (lst) :
    del lst[lst[2]]  #del可以删除指定下标的数据，lst[2]=2*2=4，del掉下标4，即del掉16
    return lst
print (fun (my_list))
输出结果：
[0, 1, 4, 9]

iterating through lists with the for loop使用for循环遍历列表

#python insitute test题如下：
lst = [i for i in range(-1,-2)]
print(lst)
执行结果如下：
[]
补充说明：
for i in range(5,0):  #range(a,b)，a,b顺序需从小到大
    print(i)
执行结果如下：

Process finished with exit code 0

#python insitute test题如下：
my_list = [0, 1, 2, 3]
x = 1
for elem in my_list:
    x *= elem
print(x)
执行结果如下：
0

#python insitute test题如下：
my_list = [0 for i in range(1,3)]
print(my_list)
执行结果如下：
[0, 0]

#python insitute test题如下：
my_list = [i for i in range(-1,2)]   #range(-1,2)，包括-1,0,1，不包括2
print(my_list)
执行结果如下：
[-1, 0, 1]

initializing loops初始化循环

the in and not in operatorsin和not in操作符

list comprehensions列表推导

#python insitute test题如下：
my_list = [[0,1,2,3] for i in range(2)]
print(my_list)
print(my_list[1][0])
print(my_list[2][0])
执行结果如下：
[[0, 1, 2, 3], [0, 1, 2, 3]]
0
Traceback (most recent call last):
  File "C:/Users/18826/Desktop/01.py", line 3, in <module>
    print(my_list[2][0])
IndexError: list index out of range

#python insitute test题如下：
lst = [[x for x in range(3)] for y in range(3)]   #变量=[生成数据的规则 for 临时变量 in xxx for j in xxx]。第二个for循环循环一次，生成一个数据，得：x=0,1,2，y=0,1,2，lst=[[0,1,2]0,1,2]
for r in range(3):  #r=0,1,2
    for c in range(3):  #c=0,1,2 
        if lst[r][c] % 2 != 0:  #%取余，0%2=0，不成立，1%2!=0，成立，2%2=0，不成立，重复3次，输入3个#
            print("#")
执行结果如下：
#
#
#

补充：
lst = [[x for x in range(3)] for y in range(3)]
for r in range(3):
    for c in range(3):
         print(lst[r][c])
执行结果为：
0
1
2
0
1
2
0
1
2

copying and cloning复制和克隆

#python insitute test题如下：
nums=[1,2,3]
vals = nums
del vals[0]
print(nums)    #输入结果证明列表是动态数组，等于赋值后，改变一个会改变另一个
print(vals)
执行结果如下：
[2,3]
[2,3]

lists in lists：matrices and cubes矩阵和多维数据集：知道如何构建matrix矩阵，以及当matrix在运算中如何读取正确结果

#python insitute test题如下：
my_list = [[0, 1, 2, 3] for i in range(2)]
print(my_list[2][0])   #列表my_list第三个列表下标0
执行结果报错
解题：
my_list = [[0, 1, 2, 3] for i in range(2)]  #列表[0,1,2,3]循环2次
print(my_list)
执行结果如下：
[[0, 1, 2, 3], [0, 1, 2, 3]]
得：print(my_list[2][0])   #列表my_list第三个列表下标0
语句修改如下：
my_list = [[0, 1, 2, 3] for i in range(3)]
print(my_list[2][0])
执行结果如下：
0

#python insitute test题如下：
t = [[3-i for i in range(3)] for j in range(3)]  #t = [[3, 2, 1], [3, 2, 1], [3, 2, 1]]
s = 0
for i in range(3):
    s += t[i][i]   #当range为0时，s + t[][] = 0 + t[0][0] =0 + 3 =3，当range为1时，3 + t[1][1] = 3 + 2 = 5，当range为2时，5 + t[2][2]=5 + 1 =6 
print(s)
执行结果如下：
6

#python insitute test题如下：
my_list = ['Mary', 'had', 'a', 'little', 'lamb']
def my_list(my_list):
    del my_list[3]
    my_list[3] = 'ram'
print(my_list(my_list))
执行结果如下：no output,the snippet is erroneous

PCEP-30-02 3.2 – Collect and process data using tuples

tuples： indexing, slicing, building, immutability：注意tuples元组的immutable不可变是考察重点，也即，tuples是不可以添加或者修改的，也不能挪去某一个元素，但是可以全部删除

list 是可变的对象，元组 tuple 是不可变的对象！由于 tuple 不可变，所以使用 tuple 可以使代码更安全！
直接在同一个元组上更新是不可行的，但是可以通过拷贝现有的元组片段构造一个新的元组的方式解决。单独删除一个元素是不可能的，可以利用切片的方式更新元组，间接的删除一个元素。

#python insitute test题如下：
tup = (1,2,4,8)   
tup = tup[-2:-1]  #因为元组不可变，需要通过切片进行更新，tup[-2:-1]=(4，）
tup = tup[-1]  #tup[-1]，-1是指右边第一个元素，得为4
print (tup)
执行结果如下：
4

#python insitute test题如下：
tup = (1, 2, 4, 8)
tup = tup[1:-1]  #因为元组不可变，需要通过切片进行更新，tup[1:-1]=2,4
print(tup)
tup = tup[0]     #只有一个元素，不需要() 
print(tup)
执行结果如下：
(2, 4)
2

#python insitute test题如下：
foo = (1,2,3)
foo.index(0)
执行结果如下：
    foo.index(0)
ValueError: tuple.index(x): x not in tuple

#python insitute test题如下：
my_tuple[1] = my_tuple[1] + my_tuple[0]
执行结果如下：
    my_tuple[1] = my_tuple[1] + my_tuple[0]
NameError: name 'my_tuple' is not defined

拓展：
my_tuple = (0, 1, 2, 3)
my_tuple[1] = my_tuple[1] + my_tuple[0]
print(my_tuple)
执行结果如下：
    my_tuple[1] = my_tuple[1] + my_tuple[0]
TypeError: 'tuple' object does not support item assignment

#python insitute test题如下：
tup = (1, ) + (1, )
tup = tup + tup
print(len(tup))
执行结果如下：
4

元组中 只包含一个元素 时，需要 在元素后面添加逗号

#python insitute test题如下：
tup = (1,2,4,8)
tup = tup[-2:-1]  #元组中 只包含一个元素 时，需要 在元素后面添加逗号
print(tup)
tup = tup[-1]
print(tup)
执行结果如下：
(4,)
4

#python insitute test题如下：

tuples vs. lists：similarities and differences, lists inside tuples andtuples inside lists：相似性和区别性一定要熟悉

列表和元组区别：
列表是动态数组，它们可变且可以重设长度（改变其内部元素的个数）。
元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变。

lists inside tuples and tuples inside lists元组中的列表和列表中的元组

PCEP-30-02 3.3 Collect and process data using dictionaries使用字典收集和处理数据

dictionaries: building, indexing, adding and removing keys字典:建立、索引、添加和删除键

#python insitute test题如下：
dd = { 
    "1": "0", "0": "1"}
for x in dd.vals():  #dd.values才是对的
    print (x, end="")
执行结果如下：
 for x in dd.vals():
AttributeError: 'dict' object has no attribute 'vals'

iterating through dictionaries and their keys and values遍历字典及其键和值

for循环遍历字典, 默认获取的是key

#python insitute test题如下：
dictionary = { 
   'one': 'two', 'three': 'one','two': 'three'}   #dct = {key : values}
v = dictionary['one']     #字典序列[key] = 值，得：v='two'
for k in range(len(dictionary)):   #len(dictionary)=3,循环3次
    v = dictionary[v]    #循环第一次，v=dictionary['two']='three'；循环第二次，v=dictionary['three']='one'；循环第三次，v=dictionary['one']='two'
print(v)
执行结果如下：
two

#python insitute test题如下：
dct = { 
   'one': 'two', 'three': 'one', 'two': 'three' }   #dct = {key : values}
v = dct['three']      #字典序列[key] = 值，得：v='one'
for k in range(len(dct)):   #len(dic)计算字典dic的元素个数(长度)，即键的总数。字典中每一个元素是一个键值对，len(dct)=3，rang(3)=[0,3)=0,1,2 
    v = dct[v]    #dct['one']=two，dct['two']=three，dct['three']=one，循环三次
print(v)
执行结果如下：
one

#python insitute test题如下：
my_list = ['a', 'b', 'c', 'd']
for i in range(len(my_list) - 1):
    dictionary[my_list[i]] = (my_list[i], )
for i in sorted(dictionary.keys()):
    k = dictionary[i]
print(k[0])
执行结果如下：
c

checking the existence of keys检查密钥是否存在

methods: keys(), items(), and values()方法:keys()、items()和values()：考察重点keys(), items() and values()等不同

method，注意不同method得到的结果是不一样的，给定method之后，选取正确读取答案一定要会

1、items()方法将字典里对应的一对键和值以元组的形式（键, 值），存储为所生成序列里的单个元素
2、keys()方法将字典里的每个键key以字符串的形式，存储为所生成序列里的单个元素
3、values()方法将字典里的每个值以字符串的形式，存储为所生成序列里的单个元素

#python insitute test题如下：
dd = { 
   "1": "0", "0":"1"}
for x in dd.values():
    print(x)
执行结果如下：
0
1

#python insitute test题如下：
dct = { 
    }     #dct = {key : values}
dct ['1'] =(1,2)  #字典序列[key] = 值，得'1' : (1,2)
dct ['2']= (2,1)   
for x in dct.keys ( ) :  #keys()方法将字典里的每个键以字符串的形式，存储为所生成序列里的单个元素 
    print (dct[x][1], end="")  ## print(dict1['name']) # 返回对应的值(key存在)
执行结果如下：
21
不理解，于是将dct[x][1]改为dct[x][0]
dct = { 
    }
dct ['1'] =(1,2)
dct ['2']= (2,1)
for x in dct.keys ( ) :
    print (dct[x][0], end="")
执行结果如下：
12   #推测dct[x][0]中的[0]是指下标0，指的是dct['1']和dct['2']的下标0的数字
拆分进行理解：
dct = { 
    }     #dct = {key : values}
dct ['1'] =(1,2)  #字典序列[key] = 值，得'1' : (1,2)
dct ['2']= (2,1)
print(dct)
执行结果如下：
{ 
   '1': (1, 2), '2': (2, 1)}
进一步：
dct = { 
    }     #dct = {key : values}
dct ['1'] =(1,2)  #字典序列[key] = 值，得'1' : (1,2)
dct ['2']= (2,1)
print(dct)
for x in dct.keys ( ) :  #keys()方法将字典里的每个键以字符串的形式，存储为所生成序列里的单个元素
    print (x)
执行结果如下：
{ 
   '1': (1, 2), '2': (2, 1)}
1
2

PCEP-30-02 3.4 Operate with strings操作字符串

constructing strings构建字符串

indexing, slicing, immutability索引、切片、不变性

escaping using the \ character使用\字符转义

python institue test：escape character转义符的作用：改变它旁边的字符的含义
strings in detail：escaping using the \ character, quotes and apostrophes inside strings, multi-line strings, basic string functions：详细的字符串：转义使用\字符，引号和撇号字符串，多行字符串，基本的字符串功能：考察重点是\这个escape character转义字符，每次当\出现，要注意后面所带的escape pair，以及如果自己出现，通常是为了提高代码的可读性。

字符常量中，反斜杠（\）是一个特殊的字符，称为转义字符。它的作用是用来转义后面一个字符。转义后的字符通常用于表示一个不可见的字符或具有特殊含义的字符，例如换行（\n）。一些常见的转义字符如下：
\r　　表示回车符，将光标定位到当前行的开头，不会跳到下一行。
\n　 表示换行符，换到下一行的开头。
\t　　表示制表符，将光标移到下一个制表符的位置，就像在文档中用tab键一样。
\b　　表示退格符，如同键盘上的Backspace键。

以下字符都有特殊意义，无法直接表示，所以用斜杠加上另一个字符来表示。
\’　　表示单引号字符，java代码中单引号表示字符的开始和结束，如果直接写一个单引号字符（‘）,程序会报错，程序会认为两个是一对。因此需要转义符（’）。
\”　　表示双引号字符，java代码中双引号是表示字符串的开始和结束，包含在字符串中的双引号需要转义，例如：“Lichao, “good night”.”
\\　　表示反斜杠字符，由于在java代码中的斜杠（\）是转义字符，因此需要表示字面意义上的\就需要使用双斜杠（\）。

python institute test：escape character changes the meaning of the character next to it.

quotes and apostrophes inside strings字符串中的引号和撇号

multi-line strings多行字符串

basic string functions and methods基本的字符串函数和方法

Section4：Functions and Exception(28%)函数和解释

PCEP-30-02 4.1 – Decompose the code using functions使用函数分解代码

defining and invoking your own functions and generators定义和调用您自己的函数和生成器：考察重点如何构建自己的function，构建格式是重中之重

能否将函数调用放在函数定义的上方?
。不能!
。因为在使用函数名调用函数之前，必须要保证Python已经知道函数的存在
。否则控制台会提示NameError: name ‘say_ hello’is notdefined(名称错误: say_ hello这个名字没有被定义)

return keywords, returning results返回和产生关键字，返回结果：return是考察重点

①将return后边的数据值进行返回；②程序代码遇到return，会终止(结束)执行。

#python insitute test题如下：
def f(x):
    if x == 0:
        return 0
    return x + f(x - 1)  #3+2+1
print(f(3))
执行结果如下：
6

#python insitute test题如下：
def fun(x):
    x += 1
    return x
x = 2
x = fun(x + 1)  #x = fun(3) ,fun(3)return x=4
print(x)
执行结果如下：
4

#python insitute test题如下：
def func_1(a):
    return a ** a
def func_2(a):
    return func_1(a) * func_1(a)
print(func_2(2))
执行结果如下：
16

the None keyword：注意None不能参与运算

在 Python 中有一个值称为 None，它表示没有值。None 是 NoneType 数据类型的唯一值。就像布尔值 True 和 False 一样，None 必须大写首字母 N。

#python insitute test题如下：
def function_1(a) :
    return None
def function_2 (a) :
    return function_1(a)*function_1(a)
print (function_2(2))
执行结果如下：
TypeError: unsupported operand type(s) for *: 'NoneType' and 'NoneType'

#python insitute test题如下：
def fun(x):
    if x % 2 == 0:
        return 1
    else:
        return
print(fun(fun(2)) + 1)
执行结果如下：
#没有东西输出

recursion：递归

#python insitute test题如下：

PCEP-30-02 4.2 – Organize interaction between the function and its environment

parameters vs.arguments：parameter可以shadow相同名字的variable变量，前提是在function内，并且定义里parameter

parameter和argument的区别:

1. parameter是指函数定义中参数，而argument指的是函数调用时的实际参数。
2. 简略描述为：parameter=形参(formal parameter)， argument=实参(actual parameter)。
3. 在不很严格的情况下，现在二者可以混用，一般用argument，而parameter则比较少用。

positional keyword and mixed argument passing位置关键字和混合参数传递：考察重点是positional argument必须在keyword argument前，如果顺序发了，程序会报错

位置参数和关键字参数混用：混合使用时，必须将 位置参数 写到前面，关键字参数 不用按照顺序来指定。

#python insitute test题如下：
def func(a, b):
return b ** a
print(func (b=2,2))
执行结果如下：
    return b ** a
    ^
IndentationError: expected an indented block

#python insitute test题如下：
def fun(x, y, z):
    return x + 2 * y + 3 * z
print(fun(0, z=1, y=3))
执行结果如下：
9

缺省形参：在函数定义的时候，给形参一个默认值，这个形参就是缺省参数，注意点：缺省参数要写在普通参数的后边
特点：在函数调用的时候，如果给缺省参数传递实参值，使用的是传递的实参值，如果没有传递，使用默认值

形参的个数需要和实参的个数对应，相同，不能多，也不能少

#python insitute test题如下：
def fun(a, b):
    return a ** a
print(fun(2))
执行结果如下：
    print(fun(2))
TypeError: fun() missing 1 required positional argument: 'b'

python institue test ：the meaning of the key word parameter is determined by the argument’s name specificed along with its value.关键字参数的含义由以下参数决定：参数的名称及其值。

#python insitute test题如下：
def fun (inp=2, out=3) :  #在函数调用的时候，如果给缺省参数传递实参值，使用的是传递的实参值，如果没有传递，使用默认值
    return inp * out
print ( fun (out=2))
执行结果如下：
4

default parameter values：默认参数值

给形参指定默认值：指定了默认值以后，如果用户传递了参数，则默认值没有任何作用；如果用户没有传递，则默认值就会生效。

#python insitute test题如下：
def fun(inp=2, out=3):
    return inp * out
print(fun(out=2))
执行结果如下：
4

name scopes, name hiding (shadowing),the global keyword：名称作用域、名称隐藏(隐藏)、global关键字

全局变量是在函数外部定义的变量(没有定义在某一个函数内)，所有函数内部都可以使用这个变量（如果想要修改全局变量的值，需要使用global关键字声明）

#python insitute test题如下：
def fun(x):
    global y
    y = x * x
    return y
fun(2)
print(y)
执行结果如下：
4
补充说明：去掉global y会报错，因为fun(2)是全局变量，在函数def中被改变，需要global说明

#python insitute test题如下：
def fun(x):
    x += 1
    return x
x = 2
x = fun(x + 1)
print(x)
执行结果如下：
4

#python insitute test题如下：
def any():
    print(var + 1,end='')
var = 2
any()
print(var)
执行结果如下：
32

PCEP-30-02 4.3 – Python Built-In Exceptions Hierarchy

BaseException

Exception

SystemExit

KeyboardInterrupt

abstract exceptions

ArithmeticError

LookupError

IndexError

KeyError

TypeError

typeerror：函数或方法接受了不适当的【类型】的参数，比如sum(‘nick’)，sum函数不接受字符串类型；
valueerror：函数或方法虽然接受了正确的【类型】的参数，但是该参数的【值】不适当，比如int(‘nick’)；

#python insitute test题如下：
value = input("Enter a value: ")  #input输出的字符串str
print(10/value)   #10是int，value是str，两者相除，类型上存在问题
执行结果如下：
    print(10/value)
TypeError: unsupported operand type(s) for /: 'int' and 'str'

#python insitute test题如下：
try: 
    value = input("Enter a value: ")  #input输出字符串
    print(value/value)   
except ValueError:                #传入无效的参数 
    print("Bad input...")
except ZeroDivisionError:        #除(或取模)零 (所有数据类型)
    print("very bad input...")
except TypeError:                #对类型无效的操作 
    print("very very bad input...")
except:
    print("Booo!")
执行结果如下：
Enter a value:         #要按个空格键
very very bad input...

补充说明：
value = input("Enter a value: ")  #input输出字符串
print(value/value)
执行结果如下：
    print(value/value)
TypeError: unsupported operand type(s) for /: 'str' and 'str'

ValueError

#python insitute test题如下：
foo = (1, 2, 3)
foo.index(0)
执行结果如下：
    foo.index(0)     #跟find()方法类似，查询作用
ValueError: tuple.index(x): x not in tuple

SyntaxError

Python SyntaxError语法错误原因及解决方法，Python中的SyntaxError错误是常见Python语言异常错误类型中的一种，表示语法错误，一般是代码出现错误才会报SyntaxError错误。

SyntaxError错误解决方法：解决SyntaxError错误办法很简单，知道它代表的意思是语法错误，那就要检查一下代码拼写是否有错。

#python insitute test题如下：
try:
    print (5/0)
    break
except:
    print("sorry,something went wrong...")
except (valueError, ZeroDivisionError) :
    print ("Too bad...")
执行结果如下：
    break
    ^
SyntaxError: 'break' outside loop



补充说明：
try:
    print(5/0)
except:
    print("Sorry,something went wrong ...")
except (ValueError, ZeroDivisionError):
    print("Too bad...")
执行结果如下：
    print(5/0)
    ^
SyntaxError: default 'except:' must be last  #此次表明except顺序有问题，调整顺序试下


测试：
try:
    print(5/0)
except (ValueError, ZeroDivisionError):
    print("Too bad...")
except:
    print("Sorry,something went wrong ...")
执行结果如下：
Too bad...

#python insitute test题如下：
print(Hello World)
执行结果如下：
    print(Hello World)
                ^
SyntaxError: invalid syntax

PCEP-30-02 4.4 – Basics of Python Exception Handling

try-except / the try-except Exception

try:
#some code is here.
except:
#some code is here.
lf you suspect that a snippet may raise an exception, you should place it in the try block.如果您怀疑代码片段可能会引发异常，则应该将其放在try块中。
The code that follows the except statement will be executed if the code in the try clause runs into an error.如果try子句中的代码遇到错误，则执行except语句后面的代码。

#python insitute test题如下：
try:
	value = input("Enter a value: ")
	print(int(value)/len(value))
except valueError:
	print("Bad input. . .")
except ZeroDivisionError:
	print("very bad input. . .")
except TypeError:
	print("very very bad input. ..")
except:
	print("Booo! ")
执行结果如下：
Enter a value: 0
0.0

#python insitute test题如下：
try:
    first_prompt = input("Enter the first value : ")
    a = len(first_prompt)
    second_prompt = input("Enter the second value : ")
    b = len(second_prompt) * 2
    print(a/b)
except zeroDivisionError:
    print("Do not divide by zero ! ")
except valueError:
    print("wrong value. ")
except:
    print("Error.Error.Error. ")
执行结果如下：
Enter the first value : kangaroo
Enter the second value : 0
4.0

#python insitute test题如下：

ordering the except branches对except分支进行排序

propagating exceptions through function boundaries通过函数边界传播异常

delegating responsibility for handling exceptions委托处理异常的责任