二级考级要点

基本数据类型

数据类型：数字(Number )、字符串 (String )、列表(List)、元组(Tuple )、字典(Dictionary ) 。
可变数据类型：列表、字典
不可变数据类型：数字、字符串、元组

列表-list

列表的创建

>>> list1=[1,'a',4]            #直接赋值，将元素用逗号隔开，并且用中括号括起来
>>> list2= list('Python')    #list()用于将元组或字符串转换为列表
>>> list2
['P', 'y', 't', 'h', 'o', 'n']

访问

索引

单个元素方法

>>> t=['a', 'b', 'c', 'd', 'e']
>>> t[1]
'b'
>>> t[-3]
'c'

列表的截取

列表的截取又称作列表的切片，它需要使用两个索引下标来确定切片的起始位置和结束位置。列表的截取格式为：变量[头下标：尾下标：步长]，其中步长为可选参数，如果没有步长参数，则代表步长为1;如果切片是从头开始或者是到最后结束，头下标和尾下标也可以没有，示例如下。

>>> t = ['a', 'b', 'c', 'd', 'e']
>>> t[:3]
['a', 'b', 'c']
>>> t[3:]
['d', 'e']
>>> t[-3:]
['c', 'd', 'e']

注意

1. 步长是选取间隔，正负整数均可，默认步长为1，正为从左往右，负为从右往左；
2. 开始位置下标/结束位置下标，正负整数均可，值为负代表从左往右倒数几个元素；
开始位置下标：默认第一个元素，步长为负数时，默认最后一个元素
结束位置下标：默认最后一个元素，步长为负数时，默认第一个元素
3. 不包含结束位置下标对应的数据
4. 切片始终以开始位置下标为开始，结束位置下标结束，确保切片[开始位置下标: 结束位置下标]区间有
值，否则为空表

示例

list1 = [1,2,3,4,5,6,7,8,9,10]
print(list1[2:8:3]) #[3, 6]
print(list1[2:8])  #[3, 4, 5, 6, 7, 8]
print(list1[2:])   #[3, 4, 5, 6, 7, 8, 9, 10]
print(list1[:])   #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list1[:-6:-1])#[10, 9, 8, 7, 6]

添加

append()

作用：将元素添加到列表的末尾。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.append(1)
>>> List
['a', 'b', 'c', 'd', 'e', 1]

insert()

作用：将元素插入指定的位置。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.insert(2,"Python")
>>> List
['a', 'b', 'Python', 'c', 'd', 'e']

更新

更新单个值

>>>List = ['a','b','c','d','e']
>>>List[2] = 'aa'
>>>List
['a','b','aa','d','e']

利用列表切片技术，列表的值也可以同时更新多个，如下例所示。

>>> List =  ['a','b','c','d','e']
>>> List [1:4] = [1,2,3]
>>> List
['a', 1, 2, 3, 'e']

删除

删除列表中的值有多种方法，主要的有以下4种方法。

del()

作用：删除列表中的指定下标的值，如果没有指定下标，则是删除整个变量。

>>> List =  ['a','b','c','d','e']
>>> del List[1]   # del(List[1]) 为另外一种写法
>>> List
['a', 'c', 'd', 'e']

pop()

作用：删除指定下标的元素，并返回被删除元素的内容，如果没有指定下标，则默认删除最后一个元素。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.pop(1)
'b'
>>> List
['a', 'c', 'd', 'e']
>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.pop()
'e'
>>> List
['a', 'b', 'c', 'd']

remove()

作用：移除列表里面第一次出现的指定值的元素。我们有时候需要删除某一个元素，但是不知道它在列表的什么位置，这时候使用remove()最合适。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.remove('c')
>>> List
['a', 'b', 'd', 'e']

clear()

作用：清除列表所有的元素，但是不删除列表，只是列表为空。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.clear()
>>> List
[]    #列表List依然存在，但是为空列表

排序

sort()

作用：对原列表进行排序，不返回新列表。如果指定参数，则使用指定的比较函数进行排序。

>>> List = ['e', 'b', 'a','d', 'c', 'f']
>>> List.sort()
>>> List
['a', 'b', 'c', 'd', 'e', 'f']

>>> List2 = ['e', 'b', 'a','d', 'c', 'f']
>>> List2.sort(reverse=True)
>>> List2
['f', 'e', 'd', 'c', 'b', 'a']

sorted()

作用：对可迭代的对象进行排序操作，会生成新的列表。

>>> List = [122,23,1,9,-34,546,12.3]
>>> NewList = sorted(List,reverse=True)
>>> List
[122, 23, 1, 9, -34, 546, 12.3]
>>> NewList
[546, 122, 23, 12.3, 9, 1, -34]

reverse()

作用：用于反向排列列表中的元素，并不进行排序，而是将列表里的元素进行顺序上的前后颠倒；另外，reverse()和sort()一样：都是在原列表中进行操作，所以没有返回值，但是会改变原列表的值，如下例所示。

>>> List = [122,23,1, 9,-34,546,12.3]
>>> List.reverse()
>>> List
[12.3, 546, -34, 9, 1, 23, 122]

查找元素

index()

作用：查找元素在列表中的位置，返回值为该元素在列表中的下标。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.index("c")
2
>>> List2 = ['a', 'b', 'c', 'd', 'e', 'a', 'b']
>>> List2.index("a")
0
>>> List2.index("a",2,6)
5

count()

作用：统计某个元素在列表中出现的次数，返回值为该元素的个数。

>>> List = ['a', 'b', 'c', 'd', 'e', 'a', 'b']
>>> List.count('a')
2

其他

len()—取列表的长度

>>>T = [1,2,3,4,5]
>>>len(T)
5

in—检查元素是否包含在列表中

>>>T = [1,2,3,(10,9,8)]
>>>print(8 in T)
False

max()—找出列表中的最大元素

>>>T = [21,2,3,4,5,8,0]
>>>print (max(T))
21

min()—找出列表中的最小元素

>>>T = [21,2,3,4,5,8,0]
>>>print(min(T))
0

sum()—列表求和运算

>>>T = [21,2,3,4,5,8,0]
>>>print(sum(T))
43

列表的加法运算

>>>T = [21,2,3,4,5,8,0]
>>>t = ['a', 'b', 'c']
>>>print (T+t)
[21,2,3,4,5,8,0,'a','b','c']

列表的乘法运算

>>>T = ['a', 'b', 'c', 'd']
>>>print(T*2)
['a', 'b','c','d','a','b','c','d']

元组-tuple

元组也是序列的一种，Python的元组与列表类似，不同之处有两点：

一是元组的元素不能修改；
二是元组使用小括号，列表使用中括号。

创建元组

>>> t=(1,2,3)    #正常方式
>>> t2=1,2,3    #可省略小括号
>>> t=()        #空元组
>>> t=(1,)        #一个元素的元组

元组的相关方法

元组的以下运算和方法和列表相同。

len(): 获取元组的长度。
in：检查元素是否包含在元组中。
max()：求最大元素。
min()：求最小元素。
sum()：求和运算。
+：元组的加法运算。元组虽然是不可变序列，但是依然可以进行加法运算。元组的加法是将两个元组结合在一起，形成一个新的元组，并不改变原元组的值。
*：元组的乘法运算。元组也可以进行乘法运算，和列表的乘法运算一样，也是将元组的元素重复相应的次数。
index()
count()
sorted()：由于元组是不可变序列，所以无法使用sort()进行排序，但是可以使用 sorted()进行排序，会生成一个列表，而不是元组。

字符串-str

字符串的以下运算和方法和列表相同。

字符串的访问、字符串的截取、len()、in、max()、min()、字符串的加法（连接）、字符串的乘法（重复输出）、sorted()、index()、count()

格式化输出

Python支持格式化字符串的输出，格式化输出有两种方式，一种是％, 一种是 format。

%格式化输出

%s：格式化输出字符串
%d：格式化输出整数
%f：格式化输出浮点数（%.2f保留两位小数）

>>> print("我的名字是%s，今年%d，体重%.2f斤。" % ('小明', 12,65.25) )
我的名字是小明，今年12，体重65.25斤。

format格式化输出

第一种：不设置指定位置，按默认顺序，如下例所示。

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

第二种：使用format后面的元组索引位置格式，如下例所示。

>>> print('1乘以{0}等于{0}, 2乘以{1}等于{2}。'.format(3,4,8))
1乘以3等于3, 2乘以4等于8。

第三种：使用命名方式，给每个需要格式化的位置命名，然后在format中进行变量赋值，如下例所示。

>>> print ('我叫{name}，我会的编程语言有{program1}'.format(name='张三',program1='Python'))
我叫张三，我会的编程语言有Python

replace()：替换

>>> mystr = "hello world and Tmbc and Python"
>>> print(mystr.replace('and', 'he'))
hello world he Tmbc he Python

split()

作用：字符串分割，将一个完整的字符串使用分割符分割成字符串列表。

>>> Fruits="苹果,香蕉,橘子,葡萄"
>>> Fruits1=Fruits.split(",")
>>> Fruits1
['苹果', '香蕉', '橘子', '葡萄']

join()

作用：和split()的功能刚好相反，将列表结合为字符串。

>>> Fruits=['苹果', '香蕉', '橘子', '葡萄']
>>> Fruitsl = ",".join (Fruits)
>>> Fruitsl
'苹果,香蕉,橘子,葡萄'

字典-dict

字典的创建

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}

访问字典里的值

>>> d = {"西瓜":9.6,"桃子":2,"苹果":4,"樱桃":12}
>>> d["樱桃"]
12
>>> d.get("苹果")
4

修改和新增字典

修改已有的键的值

直接使用字典名加键的方式进行赋值即可，如下例所示。

>>> d = {"西瓜":9.6,"桃子":2,"苹果":4,"樱桃":12}
>>> d["樱桃"]=20
>>> print(d)
{'西瓜': 9.6, '桃子': 2, '苹果': 4, '樱桃': 20}
>>> d['梨']=8
>>> print(d)
{'西瓜': 9.6, '桃子': 2, '苹果': 4, '樱桃': 12, '梨': 8}

说明：如果字典中已有该键，则将该键的值修改为最新的值；如果字典中没有该键，则新增该键值对。

update()函数

写法：dict.update(dict2)

dict = {'Name': '张三', 'Age': 7}
dict2 = {'Sex': '男', 'Age': 79 }
dict.update(dict2)
print (dict)  #输出{'Name': '张三', 'Age': 79, 'Sex': '男'}

注意：字典dict2中key如果在dict1中存在则修改dict1这个key对应的值，如果key不存在则dict1新增此键值对。

删除字典

del() / del

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']  # del(dict1['gender'])为另外一种写法
print(dict1)    # 结果：{'name': 'Tom', 'age': 20}

说明：如果指定键则删除对应的键值对，不指定则删除整个字典

clear()

说明：用于删除字典内所有元素

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1)  # {}

pop()

说明：删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。否则，返回 default 值。

>>> dict = {'Name': '张三', 'Age': 7}
>>> pop_obj=dict.pop('Name')
>>> print(pop_obj)
张三
>>> dict
{'Age': 7}
>>> dict.pop('aaa','不存在')
'不存在'

popitem()

说明：返回并删除字典中的最后一对键和值。

>>> dict = {'Name': '张三', 'Age': 12, 'Class': '4年级'}
>>> pop_obj=dict.popitem()
>>> print(pop_obj)
('Class', '4年级')
>>> print(dict )
{'Name': '张三', 'Age': 12}

len()—取字典的长度

>>> dict = {'牛奶':'18元','鸡蛋':'30元','薯条':'23元'}
>>> print(len(dict))
3

in—检查键是否在字典中

>>> dict = {'name':'Python', 'age': '21', 'edi': 3.7}
>>> print('Python' in dict)
False

流程控制

分支结构

单分支结构

a = 34
if a > 0:
    print('a为正数。')
print('程序已执行完。')

二分支结构

a = 34
if a > 0:
    print('a为正数')
else:
    print('a为0或者负数')
print('程序已执行完。')

多分支结构

a = 34
if a == 0:
    print('a为0。')
elif a>0:
    print('a为正数。')
else:
    print('a为负数。') 
print('程序已执行完。')

循环结构

while条件循环

条件循环语句的一般格式为：

while 判断条件：            #如果判断条件为True或者1，则为死循环
    执行代码块（循环体）


# 循环的计数器
i = 0
while i < 5:
    print('我错了')
    i += 1
print('任务结束')

for遍历循环

for循环语句的一般格式为：

for 变量 in 序列：
    执行代码块(循环体)

如下例所示。

for i in [1,2,3,4,5,6,7]:
    i = i*2
    print(i)

break和continue

break语句

break的作用是跳出当前的while循环或者for循环。

continue语句

和break语句不同，continue语句并不会跳出循环，它只是停止当次循环，然后跳回循环开始位置，继续下一次循环。

range()语句

range()一般和for循环结合起来使用，用于控制循环次数，如下例所示。

for i in range(5):         #（0~4）
    print(i)

for i in range(5,10):    #（5~9）
    print(i)

for i in range(0,100,2):#（0 2 4 9……8）
    print(i)

说明：三个参数和列表切片的三个参数类似。