快速复习Python基本语法_python语法复习

Python的特性

• Python是一种解释型、面向对象、动态数据类型的高级程序设计语言
  • 解释型： 程序不需要先编译，在运行时才翻译成机器语言，执行一次翻译一次，其执行效率低
  • 编译型：程序在执行前需要一个专门的编译过程，把程序编译成机器语言的文件，运行时不需要重新翻译，直接使用编译的结果就行了，其执行效率高，依赖编译器，跨平台性差些。如C、C++
  • 面向对象：以对象作为基本程序结构单位的程序设计语言
  • 动态数据类型：使用变量前不需要声明变量(变量类型)，编译过程中并不知道每一个变量的类型
• Python的优势：编程效率高、可移植性
• Python的劣势：运行效率低

Anaconda介绍

Anaconda介绍

Jupyter notebook快捷键

• Ctrl+回车：直接运行Cell
• Shift+回车：运行完本Cell后，跳到下一个Cell，如果没有，就新建一个Cell
• Alt+回车：运行本Cell，并插入一个Cell
• 显示行号：选中Cell，按L
• 查看相关函数参数：Shift+Tab

python3 六个标准数据类型

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）
  Python3 的六个标准数据类型中：
• 不可变数据（3 个） ：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个） ：List（列表）、Dictionary（字典）、Set（集合）。

Number

• Python3 支持 int、float、bool、complex（复数）
• 在Python 3中，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long
• 内置的 type() 函数可以用来查询变量所指的对象类型

x1 = 10
x2 = 10.0
print(type(x1),type(x2))

result:
<class 'int'> <class 'float'>
1
2
3
4
5
6

• 在 Python2 中没有布尔型，用0 表 False，用 1 表示 True。到在Python3 中，把 True 和 False 定义成了关键字，但它们的值还是 1 和 0，可以和数字进行运算
• Python可以同时为多个变量赋值，如a, b = 1, 2
• 在混合计算时，Python会把整型转换成为浮点数
• 将number类型转换为字符串类型：str()
• 运算：

a, b = 5, 3
print(a/b)  #除法，结果为小数 
print(a%b)  # 取模，返回除法的余数
print(a**b) #5的立方
print(a//b)# 取整除数 
1
2
3
4
5
'
运行
运行

string

• 加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数
• 用反斜杠 \ 转义特殊字符，如果不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串

print(r"shi\nchao\npeng")
print("shi\nchao\npeng")
result:
shi\nchao\npeng
shi
chao
peng
1
2
3
4
5
6
7

• Python 没有单独的字符类型，一个字符就是长度为1的字符串
• Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始,用数组的下标方式访问：[ ]
• Python中的字符串不能改变
• 单引号(’ ‘) 双引号(" ")一样，三引号(’’’ ‘’'或""" “”")可以表示多行字符串
• 令字符串首字母大写:title()

name = "SHI chaopeng"
print(name.title()) 

result:
Shi Chaopeng
1
2
3
4
5

• 将字符串改为全部大写或全部小写:upper(),lower()

name = "Shi Chaopeng"
print(name.upper())
print(name.lower())

result:
SHI CHAOPENG
shichaopeng
1
2
3
4
5
6
7

• 将字符串末尾的空白暂时删掉:rstrip()
• 暂时删除字符串开头空白：lstrip()
• 暂时删除字符串两头空白：strip()

name = "Shi "
print(name.rstrip())
# 永久删除
name = name.rstrip()
print(name)
1
2
3
4
5
'
运行
运行

List

创建列表+操作列表元素

• python中用 [] 表示列表，用逗号分隔其中的元素
• 可以将任何类型加入列标
• 访问列标：列表名[索引号]
• 列表索引从0开始
• 访问最后一个列表元素可以用索引：-1
• 修改、添加、删除元素

#修改列表元素
list1 = ['aa','bb','cc']
list1[0] = 'aaa'
print(list1)
#添加元素
list1.append('dd')
print(list1)
#插入元素
list1.insert(0,'a')#将’a‘插入到列表0的位置，剩下的元素后移
print(list1) 
#删除元素
#通过索引删除
del list1[0]
print(list1)
#使用pop()删除列表末尾元素，并接着使用它的值
dd = list1.pop()
print(dd)
#用pop()来删除列表中任何位置的元素，在括号内指定删除元素的索引
aaa = list1.pop(0)
print(aaa)
#根据值删除元素：remove()
list1.remove('cc')
print(list1)
#注：remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，
#就需要使用循环来判断是否删除了所有这样的值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'
运行
运行

• 使用sort()对列表进行永久性排序 - 按字母顺序排列

list1 = ['dd','cc','aa','bb']
list1.sort()
print(list1)
#按字母顺序相反的排序
list1.sort(reverse=True)
print(list1)
1
2
3
4
5
6
'
运行
运行

• 使用sorted()对列表进行临时排序

list1 = ['dd','cc','bb','aa']
print(sorted(list1))
print(list1)
1
2
3
'
运行
运行

• 倒着打印列表-反转列表元素的排列顺序:reverse()

list1 = ['dd','cc','bb','aa']
print(list1)
list1.reverse()
print(list1)
1
2
3
4
'
运行
运行

• 确定列表长度：len()

list1 = ['dd','cc','bb','aa']
print(len(list1))
1
2
'
运行
运行

操作列表-遍历列表

• 使用for循环打印list中的元素

students = ['aa','bb','cc','dd']
for student in students:    #注：for循环后面跟一个冒号  ：
    print("my name is" + " "+ student)
print("that's all")
1
2
3
4
'
运行
运行

• 函数range(初始值，结束值-1)

for value in range(1,5)
    print(value)
1
2

• 使用**range()**创建数字列表

number = list(range(1,6))
print(number)

result:
[1,2,3,4,5]
1
2
3
4
5

-使用range()指定步长:打印1-10内偶数

even_numbers = list(range(2,11,2))
print(even_number)
1
2

• 例子

squares = []
for value in range(1,11):
    squares.append(value**2)
print(squares)
1
2
3
4
'
运行
运行

squares = [value**2 for value in range(1,11)]
print(squares)
1
2
'
运行
运行

• 对数字列表执行简单统计的函数：min() max() sum()

digits = [1,2,3,4,5,6,7,8,9]
print(min(digits))
print(max(digits))
print(sum(digits))
1
2
3
4
'
运行
运行

• 处理列表部分元素-切片

students = ['aa','bb','cc','dd','ee','ff','gg']
print(students[0:3])   #取下标为0、1、2的元素
print(students[1:4])   #取下标为1、2、3的元素
print(students[:4])    #取下标为0、1、2、3的元素
print(students[2:])    #取小标为2到末尾的元素
print(students[-3:])   #去列表后3个元素
for student in students[1:4]:    #遍历下标1-3的元素
    print(student)
1
2
3
4
5
6
7
8
'
运行
运行

• 复制列表:copy_students = students[:]

students = ['aa','bb','cc','dd','ee']
#copy_students是将students列表又复制了一份，与students有不同的内存空间
copy_students = students[:]
#将students的指针赋值给了copy_point,所以对copy_point操作与对students操作效果相同
copy_point = students   
print(students)
print(copy_students)
print(copy_point)
students.append('origen')
copy_students.append('copy')
copy_point.append('point')
print(students)
print(copy_students)
print(copy_point)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

Tuple（元组）

• python将不能修改的值称为不可变的，不可变的列表称为元组
• 元组用圆括号标识

dimensions = (200,50)  #元组用圆括号
print(dimensions[0])   #访问下标时用方括号
print(dimensions[1])
dimensions[0] = 100    #报错：因为元组的元素不能被改
1
2
3
4

• 遍历元组

dimensions = (200,50)
for dim in dimensions:
    print(dim)
1
2
3
'
运行
运行

• 修改元组变量-不能修改元组的元素，但可以给存储元组的变量赋值

test_tuple = (10,20,30,40)
print(test_tuple)
test_tuple = (10,20,30,50)
print(test_tuple)
#注：我们不能通过下标改变元组中元素的某个值，但是我们可以重新为一个元组赋值
#重新为元素赋值的这个过程类似于对元组初始化
1
2
3
4
5
6
'
运行
运行

• 如果需要存储一组值在整个生命周期内都不变，可使用元组

Dictionary（字典）

• 作用：将相关信息关联起来
• 组成：键值对，其中键关联的值可以是数字、字符串、列表乃至字典。可以将任何python对象用作字典中的值
• 键和值之间用冒号隔开，键值对之间用逗号隔开

#创建空字典
alien_0 = {}
#添加键值对
alien_0['color'] = 'green'
alien_0['points'] = 5
alien_0['x_position'] = 0
alien_0['y_position'] = 25
#取值输出
print('points 的值为' + str(alien_0['points']))
print(alien_0)
#修改字典中的值
alien_0['color'] = 'yellow'
print(alien_0)
#删除键值对
del alien_0['points']
print(alien_0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'
运行
运行

• 注：添加键值对的顺序与字典中的排列顺序可能会不一致，因为python只关心键值对之间的关联关系，不关心添加顺序
• 遍历字典items(), keys(), values()

user_0 = {
    'userName' : 'shichaopeng',
    'email' : '1111@qq.com',
    'phone' : '123456',
    'age' : '23',
    }
for key,value in user_0.items():
    print('key:' + key + ' ; ' + 'value:' + value)
for key in user_0.keys():
    print('key:' + key)
for value in user_0.values():
    print('value:'+ value)
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

• 按顺序遍历字典中的所有键:sorted()

user_0 = {
    'userName' : 'shichaopeng',
    'email' : '1111@qq.com',
    'phone' : '123456',
    'age' : '23',
    'bb' : '33',
    'cc' : '44',
    }
for key in sorted(user_0.keys()):
    print(key)
1
2
3
4
5
6
7
8
9
10
'
运行
运行

• 字典列表

alien_0 = {'color':'green','points':5}
alien_1 = {'color':'red','points':10}
alien_2 = {'color':'blue','points':15}

aliens = [alien_0,alien_1,alien_2]
print(aliens)
for alien in aliens:
    print(alien)
1
2
3
4
5
6
7
8
'
运行
运行

• 在字典中存储列表，将列表存储在字典中

pizza = {
    #crust:包装，toppings：配料
    'crust' : 'thick',
    'toppings' : ['mushrooms','extra cheese'],
    }
print('Your ordered a' + pizza['crust']+'-crust pizza'+
    'with the following toppings:')
for topping in pizza['toppings']:
    print('\t'+topping)
1
2
3
4
5
6
7
8
9
'
运行
运行

favorite_languages = {
    'jen' : ['python','ruby'],
    'sarah' : ['c'],
    'edward' : ['ruby','go'],
    'phil' : ['python','haskell'],
    }
for name,languages in favorite_languages.items():
    print('\n'+name.title()+"'s favorite languages are:")
    for language in languages:
        print('\t'+language.title())
1
2
3
4
5
6
7
8
9
10
'
运行
运行

• 在字典中存储字典

if语句

• 实例:if-else语句

names = ['aa','bb','cc','dd','ee']
for name in names:
    if name == 'aa':
        print('aa'
    else:
        print('非aa')
1
2
3
4
5
6

• 运算符：算术运算符、比较运算符、逻辑运算符、成员运算符。除了算术运算符得到的结果是具体的值外，剩下的结果均为True或False
• 比较运算符

a, b = 21, 10
print(a == b)  # 等于
print(a != b)  # 不等于
print(a > b)  # 大于
print(a < b)  # 小于
print(a >= 21)  # 大于等于
print(a <= 2)  # 小于等于

result:
False
True
True
False
True
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 逻辑运算符

print(True and False)  # and：且
print(True or False)  # or：或
print(not True)  # not：非
print('-----')
# 布尔型的本质：True的值等于1，False的值等于0
print(True>0)
print('-----')
print(bool(0),bool(3),bool(-1),bool([1,2,3]),bool(0))
# bool()函数：将值转换为布尔型，其中只有以下情况bool()返回False：
#0, 0.0, None，'', [] , {}

result:
False
True
False
-----
True
-----
False True True True False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 成员运算符

lst = [1,2,3,4,5,6]
a,b = 1,10
print(a in lst)  # a 在 lst 序列中 , 如果 x 在 y 序列中返回 True。
print(b not in lst)  # b 不在 lst 序列中 , 如果 x 不在 y 序列中返回 True。

result:
True
True
1
2
3
4
5
6
7
8

• if语句通过以上的Ture和False判断是否执行子语句
• if语句

a = 10
if a == 10:
    print("a==10")
1
2
3
'
运行
运行

• if-elif-else结构:if语句如果满足第一个判断，就会执行此判断下的子语句并跳过余下判断

#如果输入是3，那么第一个判断满足，输出--- <4 --- ,然后程序跳过余下判断，结束此结构
age = 12
if age < 4:
    print('--- <4 ---')
elif age < 18:
    print('--- 4<age<18 ---')
elif age < 20:
    print('--- 18<age<20 ---')
else:
    print('--- >18 ---')
1
2
3
4
5
6
7
8
9
10
'
运行
运行

• 使用if语句处理列表

students = ['aa','bb','cc','dd']
for student in students:
    if student == 'aa':
        print('aa')
    elif student == 'bb':
        print('bb')
    elif student == 'cc':
        print('cc')
    elif student == 'dd':
        print('dd')
1
2
3
4
5
6
7
8
9
10
'
运行
运行

students = ['aa','bb','cc','dd']
if 'aa' in students:
    print('aa')
if 'bb' in students:
    print('bb')
1
2
3
4
5
'
运行
运行

available_toppings = ['mushrooms', 'olives', 'green peppers',
                      'pepperoni', 'pineapple', 'extra cheese']
requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
for requested_topping in requested_toppings:
    if requested_topping in available_toppings:
        print("Adding "+requested_topping+".")
    else:
        print("Sorry, we don't have "+requested_topping+".")
print("\nFinished making your pizza!")
1
2
3
4
5
6
7
8
9
'
运行
运行