Python学习笔记（一）

一、变量和简单数据类型

（一）变量

• 变量的命名和使用
  • 变量名只能包含字母、数字和下划线。不能以数字开头。
  • 变量名不能包含空格，用下划线。
  • 不要将python关键字和函数名用作变量名。
  • 要简短、具有描述性。
  • 小写字母l和数字1，大写字母o和数字0

（二）字符串

用引号括起的。（包括单引号、双引号）

• 使用方法修改字符串的大小

name = 'may zheng'

name.title()    # 以首字母大写的方式显示每个单词（其他字母为小写）
name.lower()    # 改为全部小写
name.upper()    # 改为全部大写

• 合并（拼接）字符串

# 拼接
first_name = 'may'
last_name = 'zheng'
full_name = first_name + ' ' + last_name

print('hello, ' + full_name.title() + '!')

• 使用制表符或换行符来添加空白
  • 制表符\t
  • 换行符\n
• 删除空白

language = ' python '

# 不改变变量本身内容
language.rstrip()    # 删除末尾空白
language.lstrip()    # 删除开头空白
language.strip()     # 删除两端空白

（三）数字

加（+）减（-）乘（*）除（/），乘方（**）

• 整数
• 浮点数
• 使用函数str()避免类型错误

# 将非字符串值表示为字符串
str(21)

（四）注释

• 注释用井号（#）标识
• 一般井号后空一格再标注

二、列表简介

（一）列表

• 用方括号（[]）来表示列表，用逗号（,）分隔其中元素
• 列表是有序集合
• 访问列表元素，索引从0开始

fruits = ['apple', 'banana', 'orange', 'watermelon']

print(fruits[0])    # 访问列表第一个元素，输出apple
print(fruits[-1])   # 访问列表最后一个元素，输出watermelon

（二）修改、添加和删除元素

• 修改列表元素

fruits = ['apple', 'banana', 'orange', 'watermelon']

fruits[0] = 'pineapple'
print(fruits)

---

# 输出
['pineapple', 'banana', 'orange', 'watermelon']

• 在列表中添加元素

fruits = ['apple', 'banana', 'orange', 'watermelon']

fruits.append('pineapple')    # 在列表末尾添加元素
print(fruits)
fruits.insert(1, 'grape')    # 在列表索引1处插入元素
print(fruits)

---

# 输出
['apple', 'banana', 'orange', 'watermelon', 'pineapple']
['apple', 'grape', 'banana', 'orange', 'watermelon', 'pineapple’]

• 在列表中删除元素
  • 使用del语句　　　　

del fruits[0]    # 使用del语句删除列表任何位置处的元素，必须知道索引

• • 使用方法pop()删除末尾元素

fruits.pop()    # 弹出列表末尾的值

• • 弹出列表中任何位置处的元素

fruits.pop(0)    # 弹出列表索引0处的元素

ps:如果要从列表删除一个元素，且不再以任何方式使用它，就用del语句；如果要在删除元素后还能使用它，使用方法pop()。

• • 根据值删除元素

fruits.remove('apple')    # 知道要删除的元素的值，使用remove()删除列表元素时，也可接着使用它的值；且remove()只删除第一个指定的值，如果重复出现此值，可通过循环判断

（三）组织列表

调整列表内元素的排列顺序

• 使用方法sort()对列表进行永久性排序

fruits.sort()    # 永久性地修改列表元素的排列顺序，按字母顺序排列的
fruits.sort(reverse=true)    # 按与字母顺序相反的顺序排列列表元素

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

sorted(fruits)    # 按字母顺序显示该列表
sorted(fruits, reverse=true)    # 按与字母顺序相反的顺序显示列表

• 倒着打印列表

fruits.reverse()    # 永久性反转列表排列顺序

• 确定列表的长度

len(fruits)    # 使用函数len()可快速获悉列表长度

三、操作列表

（一）遍历整个列表

• for循环
  • 注意缩进，冒号

fruits = ['apple', 'banana', 'orange', 'watermelon']

for fruit in fruits:    # 对于临时变量，可指定任何名称（使用单复数名称很方便）；打印列表中的每个元素
    print(fruit)

（二）创建数值列表

• 使用函数range()

for value in range(1,5):
    print(value)                  # 打印数字1~4，输出不包含括号第二个值

• 使用range()创建数字列表
  • 可使用函数list()将range()的结果直接转换为列表

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

---

# 输出
[1, 2, 3, 4, 5]

• • 使用函数range()时，可指定步长

numbers = list(range(2,11,2))    # 打印2~10中的偶数
print(numbers)

---

# 输出
[2, 4, 6, 8, 10]

squares = []
for value in range(1,11):
    squares.append(value**2)    # 将1~10的平方添加到列表中，平方数列表

print(squares)

---

# 输出
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

• 对数字列表执行简单的统计计算

digits = list(range(0,10))

min(digits)    # 找出列表最小值
max(digits)    # 找出列表最大值
sum(digits)    # 计算数字列表的总和

• 列表解析

squares = [value**2 for value in range(1,11)]    # 平方数列表，注意这里的for语句末尾没有冒号

（三）使用列表的一部分

• 切片

fruits = ['apple', 'banana', 'orange', 'watermelon']
print(fruits[0:3])    # 打印列表索引0、1、2的元素

---

# 输出也为一个列表
['apple', 'banana', 'orange']

print(fruits[:3])    # 没有指定第一个元素，自动从列表开头开始
print(fruits[2:])    # 打印索引2到列表末尾的所有元素

# 使用负数索引可以输出列表末尾的任何切片
print(fruits[-3:])    # 此处打印列表末尾三个元素

• 遍历切片
• 复制列表

# 可再创建一个包含整个列表的切片
fruits[:]    # 同时省略起始索引和终止索引

（四）元组

• 列表适合用于存储在程序运行期间可能变化的数据集，列表是可以修改的。
• 定义元组
  • 元组是不可变的列表，其中元素是不可修改的。
  • 使用圆括号；可以使用索引访问元组元素

digits = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
print(digits[0])

• • 不能给元组的元素赋值
• 遍历元组中的所有值

digits = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
for digit in digits:
    print(digit)          # 使用for循环

• 修改元组变量，即重新定义一个元组赋给原来的变量

digits = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
digits = (1, 2, 3, 4)

（五）设置代码格式

• 格式设置指南（pep 8）python enhancement proposal 
• 缩进，pep 8建议每级缩进都使用四个空格（制表符可以设置为是四个空格）
• 行长，建议每行不超过80字符；pep 8建议注释的行长都不超过72字符。
• 空行

四、if语句

• 条件测试（根据条件测试的值为true或flase来决定是否执行if语句中的代码）

#检查是否相等（==）
>>>age = 22
>>>age == 22
true

#检查是否不相等（!=）
>>>age != 22
false

#比较数字（<，>，>=，<=）
>>>20 > 5
true
>>>20 <= 5
false

#检查多个条件（and，or）
>>>20 > 5 and 20 < 6
false
>>>20 > 5 or 20 < 6
true

#检查特定值是否包含在列表中（in）
>>>numbers = [1, 2, 3]
>>>1 in numbers
true

#检查特定值是否不包含在列表中（not in）
>>>2 not in numbers
false

#布尔表达式，通常用于记录条件，为跟踪程序状态或条件提供高效了一种方式
game_active = true
can_edit = false

• if语句
  • 简单的if语句：一个测试和一个操作

if conditional_test:
    do something

• • if-else语句：能够指定条件测试未通过时要执行的操作

if conditional_test:
    do something
else:
    do something

• • if-elif-else结构

if conditional_test1:
    do something
elif conditional_test2:
    do something
else:
    do something

• • 使用多个elif代码块（仅适合用于只有一个条件满足的情况）
  • 省略else代码块
  • 测试多个条件

if conditional_test1:
    do something
if conditional_test2:
    do something

• 使用if语句处理列表
  • 检查特殊元素

digits = [1, 2, 3]
for digit in digits:
    if digit == 1:
        print(digit)
    else:
        print(1)

• • 确定列表不是空的

digits = []

if digits:               # 当列表为空时返回false
    for digit in digits:
        print(digit)
else:
    print("there is nothing to print.")

• • 使用多个列表
• 设置if语句的格式（比如在==、>=、<=等比较运算符两边添加一个空格）

五、字典

• 定义字典
  • 字典是一系列键-值对，使用花括号{}
  • 键和值之间用冒号分隔，键-值对之间用逗号分隔

digits = {'one': 1, 'two': 2, 'three': 3}

print(digits['one'])

• 使用字典
  • 访问字典中的值
  • 添加键-值对（字典是一种动态结构）

digits['four'] = 4
digits['five'] = 5
print(digits)

---

# 输出新增了两个键-值对
digits = {'one': 1, 'two': 2, 'three': 3, 'five': 5, 'four': 4}    # 键-值对的排列顺序与添加顺序不同

• • • 先创建一个空字典，再往空字典里添加键-值对，以这种方式创建一个字典
  • 修改字典中的值

digits['four'] = ‘四’
digits['five'] = 5
print(digits)

---

# 输出
digits = {'one': 1, 'two': 2, 'three': 3, 'five': 5, 'four': ‘四’}

• • 删除键-值对

digits = {'one': 1, 'two': 2, 'three': 3, 'five': 5, 'four': 4}
del digits['five']    # 永久性删除，使用del语句时必须指定字典名和要删除的键
print(digits)

---

# 输出
digits = {'one': 1, 'two': 2, 'three': 3, 'four': 4}

• • 由类似对象组成的字典的格式（较大的字典）

# 在最后一个键-值对后面添加上逗号，可以为以后在下一行添加键-值对做好准备
digits = {
    'one': 1,          
    'two': 2, 
    'three': 3, 
    'four': 4,       
} 

• 遍历字典
  • 遍历所有的键-值对

for key, value in digits.items():    # 包含字典名和方法items()
    print(key + '--->' + value)
# for k, v in digits.items()  使用简单的变量名
# 输出：键-值对返回的顺序也与存储顺序不同
'one'--->1
'three'--->3
'two'--->2
'four'--->4

• • 遍历字典中所有的键

for k in digits.keys():     # 使用方法keys()返回一个包含字典中所有键对的列表
    print(k)
# for k in digits  也有相同的输出，但是不方便理解

• • 按顺序遍历字典中的所有键

for k in sorted(digits.keys()):       # 调用函数sorted()再遍历前先进行排序
    print(k)

• • 遍历字典中的所有值

for v in digits.values():     # 使用方法values()返回一个包含字典中所有值的列表
    print(v)
# 这种做法提取了字典中的所有值，没有考虑重复，如果要剔除重复项，可以使用集合（set）
for v in set(digits.values()):    # 使用函数set()返回一个不重复的列表
    print(v)

• 嵌套（将一系列字典存储在列表中或将列表作为值存储在字典中）
  • 字典列表

# 创建一个用于存储奇数和偶数的空列表
numbers = []

# 创建奇数列表和偶数列表
odds = {'one': 1, 'three': 3, 'five': 5}
evens = {'two': 2, 'four': 4, 'six': 6}
numbers.append(odds)
numbers.append(evens)

for number in numbers:
    print(number)
print(len(numbers))

---

# 输出
{'one': 1, 'three': 3, 'five': 5}
{'two': 2, 'four': 4, 'six': 6}
2

• • 在字典中存储列表

numbers = {
    1: ['one', '一'],
    2: ['two', '二'],
    3: ['three', '三'],
    4: ['four', '四'],
}
for k, v in numbers.items():
    print(k + '--->' + v)

• • 在字典中存储字典

numbers = {
    'odd': {
        1: 'one',
        3: 'three',
        5: 'five',
        },

    'even': {
        2: 'two',
        4: 'four',
        6: 'six',
        },

}