Python从入门到实践

2. 变量和简单数据类型

字符串

用单引号或双引号括起： ‘... ‘ ”...“

首字母大写：.title()

全部字母大写： .upper()

全部字母小写： .lower()

合并（拼接）字符串：+

使用制表符或换行符添加空白： \t \n

删除空白： .rstrip() .lstrip() .strip()

输出：print('lu')

数字

整数

浮点数

四则运算：+ - * /

乘方：**

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

注释

注释用井号标识：#

3. 列表

bicyles = ['trek', 'cannondale', 'redline', 'specialized']

访问列表元素：bicyles[0] #索引从0开始

修改、添加和删除元素

修改列表元素：bicyles[0]=’lu‘

添加元素到列表末尾：bicyles.append('lu')

添加元素到列表任意位置：bicyles.insert(0,'lu')

删除任意位置元素：del bicyles[0]

删除列表末尾元素：popped_bicyles=bicyles.pop()

删除任意位置元素: popped_bicyles=bicyles.pop(0)

根据值删除元素：bicyles.remove('lu') #只删除第一个指定的值

组织列表

对列表进行永久性排序：bicyles.sort() #正序

bicyles.sort(reverse=True) #反序

对列表进行临时排序：sorted(bicyles)

倒着打印列表：bicyles.reverse()

确定列表的长度：len(bicyles)

4. 操作列表

遍历整个列表

for循环打印所有元素：

for bicyle in bicyles:
　　print(bicyle)

for循环中，可对每个元素执行任何操作：

for bicyle in bicyles:
    print(bicyle.title() + ", this is mine")

for循环中，想包含多少行代码都可以，在for bicyle in bicyles后面，每个缩进的代码都是循环的一部分，且将针对列表中的每个值都执行一次

for循环结束后执行一些操作。没有缩进的代码都只执行一次，而不会重复执行:

bicyles = ['trek', 'cannondale', 'redline', 'specialized']
for bicyle in bicyles:
    print(bicyle.title() + ", this is mine")
print('Thank you')

避免缩进错误

忘记缩进

忘记缩进额外的代码行

不必要的缩进

循环后不必要的缩进

遗漏了冒号

创建数值列表

函数range()：从指定的第一个值开始，并在到达指定的第二个值停止

for value in range(1,5):
    print(value)
#结果
1
2
3
4

使用list()创建数字列表：

numbers = list(range(1,6))
print(numbers)
#结果
[1,2,3,4,5]

range()可以指定步长

numbers = list(range(2,11,2))
print(numbers)
#结果
[2,4,6,8,10]

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

numbers = [2,4,6,8,10]
min(numbers)
max(numbers)
sum(numbers)

列表解析：将for循环和创建新元素的代码合并成一行，并自动附加新元素

squares = [value**2 for value in range(1,11)]
#结果
[1,4,9,16,25,36,49,64,81,100]

使用列表的一部分

切片

bicyles = ['trek', 'cannondale', 'redline', 'specialized', 'lu']
print(bicyles[1:3])
#结果
['cannondale', 'redline']
​
print(bicyles[:3]) #没有指定第一个索引，自动从列表开头开始
#结果
['trek', 'cannondale', 'redline']
​
print(bicyles[3:]) #没有指定第二个索引，自动从列表末尾结束
#结果
['specialized', 'lu']
​
print(bicyles[-3:]) #负数索引返回离列表末尾相应距离的元素
#结果
['redline', 'specialized', 'lu']

遍历切片

bicyles = ['trek', 'cannondale', 'redline', 'specialized', 'lu']
for bicyle in bicyles[:3]:
    print(bicyle.title())

复制列表

bicyles = ['trek', 'cannondale', 'redline', 'specialized', 'lu']
my_bicyles=bicyles[:] #包含整个列表的切片
print(my_bicyles)
#结果
['trek', 'cannondale', 'redline', 'specialized', 'lu']

不使用切片时复制列表

my_foods = ['pizza', 'falafel', 'carrot cake']
#这行不通
frind_foods = my_foods #frind_foods关联到包含my_foods的列表，两个变量指向的是同一个列表
​
my_foods.append('cannoli')
frind_foods.append('ice cream')
​
print(my_foods)
print(frind_foods)
#结果
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

元组

列表非常适合用于存储在程序运行期间可能变化的数据集。

Python将不能修改的值称为不可变的，将不可变的列表称为元组。

元组定义

dimensions = (200,50)
print(dimensions[1])
#结果
200
50

遍历元组中的所有值

dimensions = (200,50)
for dimension in dimensions:
    print(dimension)

修改元组变量

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

dimensions = (200,50)
for dimension in dimensions:
    print(dimension)
    
dimensions = (400,100) #重新定义整个元组
for dimension in dimensions:
    print(dimension)

5. if语句

条件测试

检查是否相等

car = 'Bmw'
print(car == 'Bmw')
print(car == 'bmw') #区分大小写
#返回
True
False
​
car = 'Bmw'
print(car.lower() == 'bmw') #不区分大小写
#返回
True

检查是否不相等

car = 'Bmw'
print(car != 'bmw')
#返回
True

比较数字：== , <, <= , >, >=

检查多个条件

#使用and检查多个条件
(age_0 >= 21) and (age_1 >= 21)
#使用or检查多个条件
(age_0 >= 21) or (age_1 >= 21)

检查特定值是否包含在列表中：关键字 in

检查特定值是否不包含在列表中：关键字 not in

bicyles = ['trek', 'cannondale', 'redline', 'specialized', 'lu']
print('lu' in bicyles)
print('lu' not in bicyles)

布尔表达式

True/False

if语句

简单的if语句

age = 19
if age >= 18:
    print("You are old enough to vote!")

if-else 语句

age = 19
if age >= 18:
    print("You are old enough to vote!")
else:
    print("Sorry, you are too young to vote!")

if-elif-else 语句: 只要有一个测试通过，就会跳过余下的测试

age = 12
if age < 4:
    print("You are too ypung!")
elif age < 15:
    print("You are young!")
else age >20:
    print("You are no young")

使用多个elif代码块：

if-elif-elif-else

省略else代码块：

if-elif-elif-elif

测试多个条件：不管前一个测试是否通过，都将进行这个测试

bicyles = ['trek', 'cannondale', 'redline', 'specialized', 'lu']
if 'trek' in bicyles:
    print("1")
if 'cannondale' in bicyles:
    print("2")
if 'redline' in bicyles:
    print("3")

if语句处理列表

检查特殊元素

bicyles = ['trek', 'cannondale', 'redline', 'specialized', 'lu']
for bicyle in bicyles:
    if bicyle == 'lu':
        print("It is mine")
    else:
        print("No")

确定列表不是空

bicyles = []
if bicyles:
    print("yes")
else:
    print("no")
#输出
no

使用多个列表

bicyles = ['trek', 'cannondale', 'redline', 'specialized', 'lu']
bicyles2 = ['trek', 'hong', 'lu']
for bicyle in bicyles2:
    if bicyle in bicyles:
        print(bicyle + " yes")
    else:
        print(bicyle + " no")

设置if语句的格式

在诸如==、>=、<=、>、<等比较运算符两边各添加一个空格，不会影响对代码的解读，而只是让代码阅读起来更容易

6. 字典

一个简单的字典

alien = {'color': 'green', 'points': 5}
print(alien['color'])
print(alien['points'])
#输出
green
5

使用字典

字典用放在{}中的一系列键-值对表示，键-值对是两个相关联的值。

键和值之间用冒号分割，键-值对之间用逗号分割。

访问字典中的值

获取与键相关联的值，可依次指定字典名和发放在方括号内的键：

print(alien['color'])

添加键-值对

字典是一种动态结构

alien = {'color': 'green', 'points': 5}
print(alien)
alien['x_position'] = 0
alien['y_position'] = 25
print(alien)
#输出
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}

Python不关心键-值对的添加顺序，只关心键和值之间的关联关系

先创建一个空字典

alien = {}
alien['color'] = 'green'
alien['points'] = 5

修改字典中的值

alien['color'] = 'yellow'

删除键-值对

del alien['point']

由类似对象组成的字典

favorite_languages={
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
}

遍历字典

遍历所有的键-值对

items()

声明两个变量，用于存储键-值对中的键和值。for循环第二部分包含字典名和方法items()

遍历字典时，键-值对的返回顺序也与存储

for name, language in favorite_languages.items():
    print(name.title()+"'s favorite language is '" + language.title() + ".")

遍历字典中所有的键

keys() #可省略，输出不变

返回一个列表，其中包含字典中所有的键

favorite_languages={
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
}
for name in favorite_languages.keys():
    print(name.title())

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

for循环中对返回的键进行排序

favorite_languages={
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
}
for name in sorted(favorite_languages.keys()):
    print(name.title())

遍历字典中所有的值

values() 没有考虑重复

set() 剔除重复项

favorite_languages={
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
}
for language in favorite_languages.values():
    print(language.title())
print('\n')
for language in set(favorite_languages.values()):
    print(language.title())

嵌套

将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套

字典列表

alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
    print(alien)

在字典中存储列表

每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表

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 language are:")
    for language in languages:
        print("\t" + language.title())

users = {
    'aeinstein': {
        'first': 'albert',
        'last': 'alinstein',
        'location': 'princeton',
    },
    'mucrie': {
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
    }
}
for username, user_info in users.items():
    print("\nUsername: " + username)
    full_name = user_info['first'] + " " + user_info['last']
    location = user_info['location']

    print("\tFull name: " + full_name.title())
    print("\tLocation: " + location.title())