Python笔记1-6

Python

变量和简单的数据类型

# title()以首字母大写来显示每个单词
first = " "
last = " "
full = first+last  
"abcd" + full + "!"   # 用 + 连接字符串
# 删除空白  调用lstrip()  rstrip()   strip()
full.strip()
# 字符串和数字共同使用的时候，要把数字转为字符串  str()  不然会报错
age = 18
message = full + str(age)
print(message)

列表

# 列表，相当于栈的感觉，里面的元素用逗号隔开
bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)   #打印列表的内部表示  包括[]
# ['trek', 'cannondale', 'redline', 'specialized']

print(bicycles[0]) # 访问列表的某个元素，在方括号指明索引，索引值从0开始
# trek   （负数是合法的，负数从最后往前数）

print(bicycles[0].title())   # Trek
# (bicycles[0]是字符串，因此可以调用字符串的方法，如title(),strip()等

# 修改列表元素 找到要修改的然后重新赋值
motorcycles[0] = 'ducati'

# 列表插入元素  1.append(),在列表尾部加入  2.insert(),可以在指定位置插入
motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.append('yamaha')   # 在列表末尾插入元素yamaha
motorcycles.insert(0, 'ducati')   # 在列表索引值为0 的位置  插入元素ducati

#删除列表元素  1.使用del语句  2.使用pop() [1.2知道要删除元素在列表中的索引值]  3.根据元素值删除元素remove()
motorcycles = ['honda', 'yamaha', 'suzuki']
del motorcycles[1]  # del是一条删除语句   del 列表名[索引值]

last_owned = motorcycles.pop() # 相当于栈，用pop()弹出栈顶元素 将删除的元素存储在一个变量中
first_owned = motorcycles.pop(0) # 可以在pop()内传入索引值，指定要删除的元素，不给值则默认删除最后一个
#对于pop()和del语句，虽然都可以指定删除，区别在于对于删除元素后面是否还会使用到，若用到则用pop()删除，然后让变量存起来，如果后面不再使用，就用del语句

motorcycles.remove('ducati') # 根据元素值删除元素
# remove()只删除列表中第一个要删除的元素，即如果有多个，也只删除一个，若要都删除，进行循环

#组织列表  排序（按字母表顺、逆序【保留原序列】   反转列表顺序）
#对列表进行排序 sort()  sort()方法是不可逆的，一旦调用，则无法还原到原来顺序
cars = ['bmw', 'audi', 'toyota', 'subaru'] 
cars.sort() 
print(cars)  # ['audi', 'bmw', 'subaru', 'toyota']
# sort()默认字母表顺序排序  若相反，向sort() 方法传递参数reverse=True   
cars.sort(reverse=True)  # ['toyota', 'subaru', 'bmw', 'audi']

# 如果想要排序，且保留原来顺序，使用sorted函数  
#不要和sort()方法乱了   方法调用： 列表名.方法名   函数调用：  函数名(传入的参数或变量)
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(sorted(cars))  # ['audi', 'bmw', 'subaru', 'toyota']  若要逆序，同样传递参数reverse=True

#反转列表顺序  reverse()方法  虽然是永久性修改，但是再次调用reverse()就回去了
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.reverse() 
print(cars)  # ['subaru', 'toyota', 'audi', 'bmw']

# 确定列表长度  使用函数len()
cars = ['bmw', 'audi', 'toyota', 'subaru']
len(cars)   # 4

操作列表

# 遍历列表 for循环
magicians = ['alice', 'david', 'carolina'] 
for magician in magicians:
	print(magician)
	print(magician.title())  # 执行不同操作
# 注意点：1.冒号别忘了  2.循环体内的语句记得缩进

# 创建数值列表 range()函数生成一系列数字
for value in range(1,5): 
	print(value)   #生成1 2 3 4 竖着排列   print语句自动换行
#  函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止

# 创建数字列表 首先，range()函数生成一系列数字，再使用list()函数将range()结果转化为列表
numbers = list(range(1,6))  # 将range()作为list()参数，numbers存储生成的列表
print(numbers)  # [1, 2, 3, 4, 5]

# 使用range()函数，可以指定步长 	range(开始,结束,步长)
even_numbers = list(range(2,11,2)) 
print(even_numbers)		# [2, 4, 6, 8, 10]

# 创建1-10平方的列表
squares = [] 
for value in range(1,11): 
	square = value**2 		 # **幂次方运算
	squares.append(square) 
	
	print(squares)		# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#对数字列表执行相关操作
digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
min(digits)  # 0
max(digits)  # 9
sum(digits)  #45

# 处理列表的部分元素————切片
players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print(players[1:4])    # ['martina', 'michael', 'florence']   相当于打印列表
# 列表名[开始索引:结束索引]   没有指定开始，默认从第一个，没有指定结束，默认到结尾 
print(players[:])  # 打印全部，从开头到结尾
# 负数索引表示从后往前  players[-3:]   即打印最后三个

# 遍历切片
players = ['charles', 'martina', 'michael', 'florence', 'eli']
for player in players[:3]:    # 切片得出来的相当于一个新的列表   for再遍历列表
	print(player.title())
# 复制列表   要复制列表，可创建一个包含整个列表的切片。
my_foods = ['pizza', 'falafel', 'carrot cake'] 
friend_foods = my_foods[:]  # 同时省略开始和结束索引
friend_foods = my_foods   # 不能直接复制，这样直接复制这两个遍历都指向了同一个列表，不是独立的，不能进行独立操作 

元组

# 列表是可以修改的，而元组不可修改
# 列表用 [] 来标识 元组用 () 标识  都是使用索引来访问
dimensions = (200, 50)
print(dimensions[0]) 
print(dimensions[1])

# 遍历元组
for dimension in dimensions: 
	print(dimension)
# 元组的值不能修改，是指不能直接修改指定索引的值
# 可以重新定义元组，在定义的时候给新值（定义了一个新的元组变量，虽然是同名，再进行赋值，给元组变量赋值是合法的，达到了修改的效果，有种同名覆盖的感觉）	
dimensions = (200, 50)
dimensions = (400, 100)  # 这样也相当于进行了修改 

dimensions = (200, 50) 
dimensions[0] = 250  # 这是不可行的，不能直接对元组指定索引值进行修改

if语句

cars = ['audi', 'bmw', 'subaru', 'toyota'] 
for car in cars: ❶ 
	if car == 'bmw': 
		print(car.upper()) 
	else:
		print(car.title())
# if else 的冒号别忘了   关于字符串的一些 lower()、upper()、title()等方法 在比较时可以使用
# ==  !=    >=    <=  		检查多个条件  and    or
# 检查特定元素是否在列表内  不在列表内  使用in 和 not in 关键字
requested_toppings = ['mushrooms', 'onions', 'pineapple'] 
if 'mushrooms' in requested_toppings 

banned_users = ['andrew', 'carolina', 'david']
user = 'marie'
if user not in banned_users:
	print(user.title() + ", you can post a response if you wish.")

# 多个条件判断  if-elif-else    注意冒号别忘了
age = 12 
if age < 4:
	price = 0 
elif age < 18: 
	price = 5 
else:    # else 代码块不是必须的
	price = 10 
print("Your admission cost is $" + str(price) + ".")
# 注意，字符串和数字，用str()函数，将整数转化为字符串，否则编译器报错

requested_toppings = ['mushrooms', 'green peppers', 'extra cheese'] 
for requested_topping in requested_toppings: 
	if requested_topping == 'green peppers': 
		print("Sorry, we are out of green peppers right now.") 
	else:
		print("Adding " + requested_topping + ".") 
print("\nFinished making your pizza!")
# for循环中嵌套if  进行条件判断  注意冒号

# 在if 语句中将列表名用在条件表达式中 时，Python将在列表至少包含一个元素时返回True ，并在列表为空时返回False
requested_toppings = [] 
if requested_toppings: 
	for requested_topping in requested_toppings: 
		print("Adding " + requested_topping + ".") 
	print("\nFinished making your pizza!")
else:print("Are you sure you want a plain pizza?")
# 如果列表为空  执行什么操作  非空执行什么操作

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!")

字典

# 字典，有种结构体的感觉  字典用 {} 进行标识
alien_0 = {'color': 'green', 'points': 5}  # 键值对   键和值之间用 ： 分隔  键值对之间用 , 分隔
# 用键来访问与之相关联的值，与键相关联的值可以是数字、字符串、列表乃至字典。

#访问字典中的值    获取与键相关联的值，依次指定字典名和放在方括号内的键
alien_0 = {'color': 'green'}
print(alien_0['color'])   # green
# 字典中可以包含任意数量的键值对

# 添加键值对
alien_0 = {'color': 'green', 'points': 5} 
print(alien_0) 
alien_0['x_position'] = 0    # 指出新的键名 再给出对应的值
alien_0['y_position'] = 25 
print(alien_0)
# {'color': 'green', 'points': 5}   新增前
# {'color': 'green', 'points': 5, 'y_position': 25, 'x_position': 0}   新增后
#字典、列表、元组都是类似的，直接print(名字)，打印出来对应的字典或者...包括标识【()、[]、{} 】都打印的
#注意，键—值对的排列顺序与添加顺序不同。Python不关心键—值对 的添加顺序，而只关心键和值之间的关联关系。

#修改字典中的值，和添加键值对一样，都是指定键名给出键值
alien_0 = {'color': 'green'} 
print("The alien is " + alien_0['color'] + ".") 
alien_0['color'] = 'yellow' 
print("The alien is now " + alien_0['color'] + ".")

# 删除键值对 使用del语句
alien_0 = {'color': 'green', 'points': 5} 
del alien_0['points'] 
# 指定键名进行删除 同时键值也对应删除

favorite_languages = { 
	'jen': 'python',
	'sarah': 'c', 
	'edward': 'ruby', 
	'phil': 'python', 
	}    # 这样看起来方便  格式
	
# 遍历字典
# for循环遍历字典 声明两个变量 对应字典中的键和值
user_0 = { 
	'username': 'efermi', 
	'first': 'enrico', 
	'last': 'fermi', 
	} 
for key, value in user_0.items(): 
	print("\nKey: " + key)  
	print("Value: " + value)
# item()方法把字典中每对key和value组成一个元组，并把这些元组放在列表中返回
# 即便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。

# 尽可能的将变量命名实义化
favorite_languages = { 
	'jen': 'python', 
	'sarah': 'c', 
	'edward': 'ruby', 
	'phil': 'python', 
	}
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())
# 调用item()返回键名和键值组成的列表  调用keys()返回键名

# 按顺序遍历字典中的所有键
favorite_languages = { 
	'jen': 'python', 
	'sarah': 'c', 
	'edward': 'ruby', 
	'phil': 'python', 
	} 
for name in sorted(favorite_languages.keys()): 
	print(name.title() + ", thank you for taking the poll.")
# 先得到有键名组成的列表favorite_languages.keys()，再使用sorted()函数创建列表副本，最后使用for循环遍历得出有序的键名

#同理，使用values()函数，可得到键值
for language in favorite_languages.values(): 
	print(language.title())
# 得到键值组成的列表再遍历输出，这样是全部输出，可能会有重复。使用集合set，类似于列表，但是有唯一性（不重复）
for language in set(favorite_languages.values()): 
	print(language.title())
# 通过对包含重复元素的列表调用set() ，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。

#字典嵌套
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)  # 输出列表中的三个字典
# {'color': 'green', 'points': 5} 
# {'color': 'yellow', 'points': 10} 
# {'color': 'red', 'points': 15}

# 在字典中存储列表   存储所点比萨的信息
pizza = { 
	'crust': 'thick', 
	'toppings': ['mushrooms', 'extra cheese'],    # 键名toppings，关联的键值是一个列表
	}
print("You ordered a " + pizza['crust'] + "-crust pizza " + "with the following toppings:")
for topping in pizza['toppings']: 
	print("\t" + topping)

# 在字典中存储字典
users = { 
	'aeinstein': { 
		'first': 'albert', 
		'last': 'einstein', 
		'location': 'princeton', 
		}, 
	'mcurie': { 
		'first': 'marie', 
		'last': 'curie', 
		'location': 'paris', 
		}, 
	}  # 定义一个字典user 存储用户信息 ，其中对应的键相关联的又是一个字典
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())
# 即username指向字典user的两个键名，user_info对应两个键名所对应的字典   user_info['first']访问嵌套内的值