1. IT知识观首页

纯干货，我自己整理的《NCT Python 一级考核知识点总结》「建议收藏」

云烟 • • 未分类 • 阅读 257

纯干货，我自己整理的《NCT Python 一级考核知识点总结》「建议收藏」这是我给学生整理的知识点，可以在考前用来快速复习，日常也可以当做速查表来用。

欢迎大家来到IT世界,在知识的湖畔探索吧!

这是我给学生整理的知识点，可以在考前用来快速复习，日常也可以当做速查表来用。

一、绪论

这个文件只罗列关键的知识点，有不熟悉的内容，可以百度 “python3 关键字”，

在检索结果中，看 “菜鸟教程”

1、python 是解释型编程语言，

设计哲学：优雅、明确、简单

语言特点：简单、开发速度快、容易学习

2、IPO 程序编写方法

input – process – output ，即输入数据 – 处理数据 – 输出数据

二、基础语法

1.标识符

变量名 、函数名就是标识符

起名规则：四不

  • 不能以数字开头
  • 不能用保留字
  • 不能用内置函数
  • 变量名之间不要有空格

2.保留字

and

as

assert

break

class

continue

def

del

elif

else

except

finally

for

from

False

global

if

import

in

is

lambda

nonlocal

not

None

or

pass

raise

return

try

True

while

with

yield

3. 注释

  • 单行：#
  • 多行用：”’……………….”’ 或 “””………………….”””

4.变量

通过赋值创建变量

a = 99      # 整型 int

st = 'hello' # 字符串 str

pi = 3.14    # 浮点型 float

c = None

欢迎大家来到IT世界,在知识的湖畔探索吧!

5.缩进

代码缩进表示代码之间的包含和层次关系。缩进用 Tab 或者 4个空格。

三、运算符和数据类型

1.算术运算符

欢迎大家来到IT世界,在知识的湖畔探索吧!+ - * /   # 加减乘除
//    # 整除
%    # 求余数
**    # 幂运算，等同内置函数 pow(m,n) , 2 ** 3 表示 2 的3次方，还可以用 pow(2,3) 来计算

注意：

# 整型 + 浮点型 还是 浮点型

a = 2 + 2.0
print(a)   # 4.0

a = 10
a = a / 2  # 除运算，结果是浮点型 
print(a)   # 5.0

a = 10
a = a // 3  # 整除运算，结果是整型    
print(a)   # 3

print(pow(2,3) == 2 ** 3)  # True

2.赋值运算符

欢迎大家来到IT世界,在知识的湖畔探索吧!=   
+=  是一种简写方式，c += a 等价于 c = c + a
-=  常见  n -= 1   等价于 n = n - 2

# 下面几个不常用
*=
/=
%=
//=
**=

# 特殊运用：
# 多变量同时赋值，等同于分别赋值，看起来更简洁

a, b, c = 9, 2.0, 'hello'

# 元组解包，一级不考
size = (800,600)
w , h = size

# 交换，python 特有的写法，
# 可以理解为从右边的变量取出当前值来，赋给左边的变量
a,b = b,a

mylist = [1,2,3,4,5]
mylist[0],mylist[-1] = mylist[-1],mylist[0]
print(mylist)  # [5, 2, 3, 4, 1]

3.关系(比较)运算符，返回的结果是 True 或者 False

==
!=
>
>=
<
<=

注意：字符之间的比较

print('a' < 'b')   # True
print('Z' < 'a')   # True

# 字符由小到大顺序： 空字符 < 空格 < 数字 < 大写 < 小写

print('' < ' ')   # True

# 可以通过 ord(字符) 查看字符在字符表中的序号

4.变量类型

4.1 整型（int)

默认10进制，其他进制的表示方式：

（1）二进制：0b 或者 0B 开头

print(0b11011)  # 27

（2）八进制：0o 、0O

（3）十六进制：0x、0X

4.2 浮点型（float）

pi = 3.14
a = 6 / 3       # 两个整数相除也会返回浮点型
b = -2.5e2      # 科学计数法 相当于 b = -2.5 * (10 ** 2) 不用括号也可以，因为 ** 优先级比较高

# 内置函数 round(x[,n]),四舍五入
pi = round(3.1415926)   # 3
pi = round(3.1415926,2) # 3.14

5.布尔类型

5.1 变量值 ：True、False

a = 11 > 10  # True
b = 11 < 10  # False
print(a,b)  # True False

5.2 逻辑运算

and
or 
not

6.运算符优先级（从高到低）

运算符

描述

**

指数 (最高优先级)

* 、/、 % 、//

乘，除，取模和取整除

+ 、-

加法减法

<= 、<、 >、 >=

比较运算符

==、 !=

等于运算符

= 、%=、 /= 、//= 、-=、 +=、 *=、 **=

赋值运算符

is 、is not

身份运算符

in 、not in

成员运算符

not、 and、 or

逻辑运算符

四、字符串

详细内容，可以看菜鸟教程

1.单引号、双引号，可以嵌套

abc = 'hello "world"'

abc = "I'm fine"

abc = 'I'm fine'  # 这样写是错误的
abc = 'I\'m fine'  # 可以用转义字符

2.三引号，用来表示多行字符串

abc = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (abc)

3.转义字符串，嵌入字符串中表示特殊字符

\'
\"
\\
\r      回车
\n      换行

4.字符串运算

字符串和列表都属于序列类型，很多操作和方法都类似，

可以通过索引获取单个字符，索引从 0 开始

可以通过切片获取字符串片段

a = ‘Hello’

b = ‘Python’

操作符

描述

实例

+

字符串连接

a + b 输出结果： HelloPython

*

重复输出字符串

a*2 输出结果：HelloHello

[]

通过索引获取字符串中字符

a[1] 输出结果 e

[ : ]

切片，截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。

a[1:4] 输出结果 ell

in

成员运算符 – 如果字符串中包含给定的字符返回 True

‘H’ in a 输出结果 True

not in

成员运算符 – 如果字符串中不包含给定的字符返回 True

‘M’ not in a 输出结果 True

r/R

原始字符串 – 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。

print( r’\n’ ) print( R’\n’ )

%

格式化字符串

5.字符串常用方法和函数

count

用来统计字符串中，某个字符或者字符串出现的次数

find

查找，返回索引

join

将列表内容用字符串连接起来，是 split 的逆操作

split

将字符串分隔成列表，没有参数就用空格切分，有参数就以参数切分

len

python 内置函数，求字符串长度

例子：

# count(str)	# 用来统计字符串中，某个字符或者字符串出现的次数
abc = 'hello world'
abc.count('l')  # 返回 3
abc.count('ll') # 返回 1

# find(str)		# 查找，返回索引
abc.find('o')	# 返回 4
abc.find('wo')	# 返回 6

# join(str_list) # 将列表内容用字符串连接起来
b = abc.split()	 # b = ['hello','world']
c = ','.join(b)  # c = 'hello,world'

# split()		 # 将字符串分隔成列表，没有参数就用空格切分，有参数就以参数切分
abc = 'a,b,c,d'
b = abc.split()	  # b = ['a,b,c,d'] 只有一个元素，因为 abc 没有空格
c = abc.split(',')# c = ['a','b','c','d'] 

# len()           # 返回字符串长度

abc = 'hello'
print(len(abc))   # 5

6.字符串遍历

# 直接元素遍历，即依次访问字符串中的字母
abc = 'hello world'
for i in abc:
    print(i)
    
'''
会打印出
h
e
l
l
o

w
o
r
l
d
'''   
# 下面代码实现同样效果，通过索引遍历
abc = 'hello world'
for i in range(len(abc)):
    print(abc[i])

7.字符串格式化


# 基本格式  s
# %s 字符串占位符
# %d 整数
# %.nf 浮点数,n 表示保留 n 位小数

abc = 'hello,%s,nice to meet you'%('Jerry')
# 'hello,Jerry,nice to meet you'

abc = '你好,%s,今天 %d 度'%('Jerry' , 26)
# '你好,Jerry,今天 26 度'

abc = '你好,%s,今天是 %d 号，气温 %f 度'%('Jerry' , 5 , 28.5)
# '你好,Jerry,今天是 5 号，气温 28.500000 度'

abc = '你好,%s,今天是 %d 号，气温 %.2f 度'%('Jerry', 5 , 28.5)
# '你好,Jerry,今天是 5 号，气温 28.50 度'

五、列表

详见菜鸟教程

1.列表创建

# 空列表
name_list = []

# 非空
name_list = ['dylan','sabrina']

# 由字符串方法创建
name_list = 'eden,sabrina,john,tom'.split(',')

# 由 list() 函数转化
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)  # list1 = [123, 'Google', 'Runoob', 'Taobao']

str = "Hello World"
list2 = list(str)     # list2 = ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

num_list = list(range(5))  # num_list = [0, 1, 2, 3, 4]

# 列表生成式,一般不会考
num_list = [2 * i for i in range(10)]

2.删除列表

mylist = [0, 1, 2, 3, 4]
del mylist  # 删除后，不能再访问 mylist

3.删除列表元素

# 1.del
mylist = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", mylist)
del mylist[2]
print("删除了第三个元素 : ", mylist)

‘’‘
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]
’‘’

# 2.remove(元素)
mylist = ['Google', 'Runoob', 1997, 2000]
mylist.remove('Runoob')
print(mylist)	# ['Google', 1997, 2000]

# 3.pop(n)   # 按索引弹出,  默认 n=-1 即删除最后一个，pop(0) 弹出第一个
mylist = ['Google', 'Runoob', 1997, 2000]
year = mylist.pop(2)
print(year,mylist)	# 1997 ['Google', 'Runoob', 2000]

mylist = ['Google', 'Runoob', 1997, 2000]
year = mylist.pop()		# 没参数
print(year,mylist)	# 2000 ['Google', 'Runoob', 1997]

# 4.clear()  # 清除全部元素
mylist = ['Google', 'Runoob', 1997, 2000]
mylist.clear()   # mylist = []

4.列表索引

需要注意的是：

  • 索引从 0 开始
  • 负数索引表示倒数，-1 表示倒数第一个，即最后一个
mylist = [1,3,5,7,9]
print(mylist[0])   # 1
print(mylist[-1])  # 9

5.切片

需要注意的是

# mylist[start:end]  只能切到 end - 1 ，到不了 end

mylist = [1,3,5,7,9]
new_list = mylist[0:-1]
print(new_list)   # [1, 3, 5, 7]

# 要想切到最后一个
new_list = mylist[0:]
print(new_list)   # [1, 3, 5, 7, 9]

# 列表逆序，一般不考
new_list = mylist[::-1]
print(new_list)   # [9, 7, 5, 3, 1]

6.修改列表

通过索引赋值

cities = ['北京','天津','上海']
cities[1] = '重庆'
print(cities)  # ['北京', '重庆', '上海']

添加 append(元素)

cities = ['北京','天津','上海']
cities.append('重庆')
print(cities)  # ['北京', '天津', '上海', '重庆']

插入 insert(索引，元素)

cities = ['北京','天津','上海']
cities.insert(1,'重庆')	# 在第 2 个元素前面插入 '重庆'
print(cities)  # ['北京', '重庆', '天津', '上海']

7.统计

# count(元素)		# 计数
num_list = [1,2,5,3,1,6,7,2,1]
print(num_list.count(1))	# 3
print(num_list.count(6))	# 1

# sum(列表)		# 合计
num_list = [1,2,5,3,1,6,7,2,1]
print(sum(num_list))	# 28

# len(列表)		# 列表长度
num_list = [1,2,5,3,1,6,7,2,1]
print(len(num_list))	# 9

# min(列表)   max(列表)  # 返回最小元素、最大元素
print(min(num_list),max(num_list),sep = ',')  # 1,7

# 求平均值,组合上面的函数
avg = sum(num_list) / len(num_list)   # 3.111111111111111

8.排序

# sort()	# 默认升序，即从小到大
num_list = [1,2,5,3,1,6,7,2,1]
num_list.sort()    #[1, 1, 1, 2, 2, 3, 5, 6, 7]

num_list.sort(reverse = True) # [7, 6, 5, 3, 2, 2, 1, 1, 1]  逆序，从大到小
# sorted(列表)  # 内置函数，返回一个排序后的新列表，原列表不发生变化
num_list = [1,2,5,3,1,6,7,2,1]
list2 = sorted(num_list)
print(num_list,list2)  #[1, 2, 5, 3, 1, 6, 7, 2, 1] [1, 1, 1, 2, 2, 3, 5, 6, 7]

9.其他


list1 = [1,2,3]
list2 = ['a','b','c']

# + 列表连接
list3 = list1 + list2
print(list3)    #[1, 2, 3, 'a', 'b', 'c']

# * 重复
list3 = list1 * 3
print(list3)    #[1, 2, 3, 1, 2, 3, 1, 2, 3]

list3 = list2 * 2 + list1 
print(list3)	# ['a', 'b', 'c', 'a', 'b', 'c', 1, 2, 3]

# 生成字符串 join(列表) 和 字符串.split() 是逆运算
st = ''.join(list2)
print(st)		# 'abc'

st = ','.join(list2)
print(st)		# 'a,b,c'

# 要想输入一个列表，可以用下面方式
st = input('请输入学生姓名，以空格分隔：')
student_list = st.split()

六、类型转换

1.int()

# int() 可以将浮点数和字符串转化为整数
# 注意，转化字符串时，字符串不能包含除数字以外的字符
a = '20.6'
b = int(a)	# 错误，常考

# 转化浮点数，会舍弃小数点后面的数字，不是四舍五入

a = 20.6
b = int(a)	 # b = 20

需要输入整数或者浮点数时，直接套在 input() 外面转化：

m = int(input(‘请输入第一个整数:’))

num1 = float(input(‘请输入:’))

2.float()

3.str()

4.list()

七、分支结构


if 条件1:
    pass
elif 条件2:
    pass
else:
    pass

易犯错误：

#1 写条件的时候，不要把 == 写成  =,如下：

if m % i = 0 and n % i = 0:
    
#2 注意加条件后面加上 :

#3 注意 缩进

八、循环结构

1.for 循环


# 常见结构
for i in range(15):
    if i == 10:
        break
    if i == 6:
        continue
    print(i)
else:
    print('end')
    
# else 在 没有执行 break 时，才会被执行，对比下面的程序
for i in range(10):
    if i == 10:
        break
    if i == 6:
        continue
    print(i)
else:
    print('end')

2.需要注意的就是：

break 		跳出循环
continue  	继续循环，其后面代码不执行
else  		在没有执行 break 时，才会被执行

range(start,end,step)
range(10)  相当于 range(0,10,1)
range 取值时，只能取到 end - 1

for i in range(1,5):
    print(i,end = '')
# 会打印 1234    

for i in range(0,5,2):
    print(i,sep = ',',end = '')
# 会打印 0,2,4

3.字符串遍历

str = 'hello world'
for i in str:
    pass

4.列表遍历

mylist = [1,5,8,7,3]
for i in mylist:
    pass

5.while 循环

一般在不确定 循环范围的时候，用 while 循环

while 条件:
    pass

# 或者，用 break 退出

while True:
    if 条件:
        break
    pass
for i in range(10):
    pass

# 等价 while 写法
i = 0
while i < 10:
    # do something
    i += 1

九、异常处理

基本结构

try:
    # 肯能出现异常的语句
except:
    # 处理异常
else:
    # 没有异常的情况下，会执行这里的语句
finally:
    # 不管有没有异常，都会执行

常见的异常：

  • 除 0 错误： print(2/0)
  • 访问超出列表范围
  • 类型转换错误，int(‘3.51’)

十、内置函数

常用的内置函数

函数

用处

示例

abs()

绝对值

min()

最小

max()

最大

sum()

合计

ord()

ord(‘a’) # 97

chr()

chr(98) # ‘b’

round(x[,n])

四舍五入(不精确)，四舍六入没问题

round(2.51) # 3

sorted()

排序

input()

print(st,sep=’ ‘,end=’\n’)

sep 默认空格，end 默认换行

int()

float()

list()

str()

len()

求字符串或列表长度

注意：

count() 不是内置函数，而是字符串和列表类的方法，所以调用的时候，前面要写对象名

st = 'hello world'
print(st.count('o'))   # 2

十一、标准库

turtle 库

基本命令与框架

import turtle as t

t.speed(0)			# 设置画笔速度，0 ~ 10
t.pencolor('blue')	# 画笔颜色
t.pensize(3)		# 画笔宽度

t.forward(100)      # 沿画笔方向前进 100,参数值为 -100 时，则背离画笔方向前进，画笔方向不变
t.left(90)			# 左转 90 度 ，也可以用 t.right(-90) 实现
t.right(120)		# 右转 120 度

t.penup()			# 抬笔
t.pendown()			# 落笔
t.goto(100,200)		# 移动到指定坐标

t.hideturtle()      # 隐藏 turtle 箭头
t.done()			# 停止画笔

常见代码：

正方形：

import turtle as t
t.pencolor('blue')	
for i in range(4):
	t.forward(200)      
	t.left(90)		
t.hideturtle()      
t.done()

三角形：

import turtle as t
t.pencolor('blue')	
for i in range(3):
	t.forward(200)      
	t.left(120)		
t.hideturtle()      
t.done()

五角星

import turtle as t
t.pencolor('red')	
t.pensize(3)		
for i in range(5):
	t.forward(200)      
	t.right(144)		
t.hideturtle()      
t.done()

六边形

import turtle as t
t.speed(2)
t.pencolor('blue')	
t.left(90)
for i in range(6):
	t.forward(80)      
	t.left(60)		
t.hideturtle()      
t.done()

选择题中出现 turtle 相关的题目，一般是填写 循环次数，或者 旋转角度

技巧：

看一下图形有多少条边，

程序循环中，每次画几条边（forward），

简单计算一下，即可得循环次数

旋转角度：360 / 边数

编程题：

一般会要求画简单图形的多重组合，需要用到多重循环

里层的循环用来画基本图形（三角形或者长方形、多边形）

外层循环，用来画多个基本图形。

注意，基本图形之间的相对角度，在每画完一次基本图形后，旋转一定角度(一般是 360/图形数量)

案例1：四个长方形

纯干货，我自己整理的《NCT Python 一级考核知识点总结》「建议收藏」 

import turtle as tt.speed(0)t.pencolor('blue')for i in range(4):	# 画 4 个长方形    for j in range(2):	# 内循环，画长方形	    t.forward(200)	    t.left(90)	    t.forward(100)	    t.left(90)    t.left(90)	# 此处较关键t.hideturtle()      t.done()

案例2：三个三角形

纯干货，我自己整理的《NCT Python 一级考核知识点总结》「建议收藏」 

import turtle as tt.speed(0)t.pencolor('blue')for i in range(3):	# 画三次    for j in range(3):	# 画三角形	    t.forward(200)	    t.left(120)    t.left(120)	# 画一个图形时，做一定旋转t.hideturtle()      t.done()

案例3：稍微复杂一些

纯干货，我自己整理的《NCT Python 一级考核知识点总结》「建议收藏」

通过观察，应该是 6 个六边形

import turtle as t
t.speed(0)
t.pencolor('blue')	
t.left(90)		# 调整初始方向
for m in range(6): # 画 6 次
    for i in range(6):  # 画六边形
    	t.forward(100)      
    	t.left(60)	
    t.left(60)
t.hideturtle()      
t.done()

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://itzsg.com/22882.html

赞 (0)
云烟云烟
0

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

联系我们YX

mu99908888

在线咨询： 微信交谈

邮件：itzsgw@126.com

工作时间：时刻准备着!

关注微信