【语法糖】python

由于我蛋协里选了机器学习方向_作死，所以要开始学习python来进行数据分析。掌握一门语言先从它的语法知识开始进入到语法糖时间。以下笔记均出自于《Python编程从入门到实践》，知识点非常基础且细致，适合零基础人群对python进行学习。
写这个博客初衷是为了监督我自己的学习。希望大家一起督促我哈哈哈
因为前面的print，变量命名等等都与C语言大同小异，就不展开讲了。此处从第三章开始

列表

怎样的是一个列表？

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

[]表明bicycles是个列表
用单引号或双引号括起来列表元素

访问元素

print(列表名)即可打印整个列表的元素

print(列表名[x])打印x索引处的元素，此处x可为负数，意为倒数第x个元素

操作元素

修改：bicycles[x] = ‘a’

添加元素

两种方法

1.append，加在列表末尾，需要1个参数

bicycles.append(‘a’)即可将a加在bicycles末尾

所以可以创建一个空列表，用append反复添加

2.insert，在列表的任意位置插入元素，需要2个参数

bicycles.insert(索引，‘a’)

删除元素

1.del语句

eg. del bicylces[0]删除bicycles中第一个元素

适用范围：删除一个元素并不再使用它

2.pop()函数

eg. a = biclcles.pop();

由C语言知识可延伸它是一个先返回栈顶元素再删除栈顶元素的函数

3.remove()函数

eg. bicycles.remove(‘ducati’) 删除bicycles中值为ducati的元素

根据元素值来删除列表中的元素

组织列表

1.sort()永久性排序

sort会按首字母大小对列表元素进行排序

语法：列表.sort()

eg.

cars = ['bmw','audi','toyota','subaru']
cars.sort()
print(cars)

若对sort传参reverse=True，则会逆字母表顺序进行排序

列表.sort(reverse=True)

cars = ['bmw','audi','toyota','subaru']
cars.sort(reverse=True)
print(cars)

注意，sort带来的修改是永久性的

2.sorted()临时性排序

语法：sorted(列表)

eg.

cars = ['bmw','audi','toyota','subaru']
print(cars)
print(cars.sorted())
print(cars)

上面这样写是错的，第3行应该写成print(sorted(cars))

cars = ['bmw','audi','toyota','subaru']
print(cars)
print(sorted(cars))
print(cars)

与sort一样，同样可以向sorted传reverse=True参数逆向排序

可是怎么传呢？

正解是

print(sorted(cars,reverse=True))

3.reverse()永久反转列表排序

cars = ['bmw','audi','toyota','subaru']
print(cars)
cars.reverse()
print(cars)
cars.reverse()
print(cars)

用两次reverse()即可恢复原来的顺序

语法：列表.reverse()

4.len()确定列表长度

cars = ['bmw','audi','toyota','subaru']
len(cars)

得到4

语法：len(列表)

---

操作列表

遍历列表

peoples = ['a','b','c','d']
for people in peoples:
	print(people)

python里的for循环 行末有冒号 :

以缩进来决定语句关系！（与C语言不同）

解析：

从peoples中取出一个一个变量赋给people

为了简便，我就把people叫做循环变量把

循环变量和列表的命名约定是前为单数，后为复数

语法：for 循环变量 in 列表:

创建数字列表

1.range()函数

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

你会惊讶地发现输出的是1，2，3，4

range()函数会从第一个参数开始数，到第二个参数停止（但并不包含第二个值）

另外range函数可以有第三个参数，为步长，若省略第三个参数即视步长为1

语法：range(begin,end)或range(begin,end,step)

for value in range(2,11,2):
    print(value)

输出2，4，6，8，10

python中**表示乘方运算

2**3即表示2的3次方

2.list()将range()返回值转换成列表

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

list的返回值是一个列表

squares = []
for value in range(1,11):
    square = value**2
    squares.append(square)
    
print(squares)

可省略临时变量更加简洁些（看个人习惯）

squares = []
for value in range(1,11):
    squares.append(value**2)
    
print(squares)

3.min,max,sum函数

看名字都看得懂是干什么用的，三个函数接受的参数是列表
返回最小值，最大值，和

4.列表解析（俗称一行code）

跟C语言里的+=一样，都是为了代码简洁，所以尽量学会叭

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

语法：列表 = [表达式 for 循环变量 in 数值列表]

解析：从数值列表中提取出值赋给循环变量，对表达式求值得到一个常量加入到列表中

切片

列表的一部分叫做切片

players = ['a','b','c','d']
print(players)
print(players[0:2])
print(players[:2])
print(players[1:3])
print(players[1:])

players[x:y]即是索引x到索引y片段的元素，不包括索引y处元素

若省略x则默认为从开头到y片段，若省略y则默认为从x到末尾片段

可以-3：

players = ['a','b','c','d','e']
print(players[-3:])

输出cde-3：-4输出空列表

复制

my_food=['pizza','falafel','carrot cake']
friend_foods = my_food[:]
my_food.append('cannoli')
friend_foods.append('ice cream')
print(my_food)
print(friend_foods) 

不指定索引下提取切片，从而创建这个列表的副本

输出

['pizza', 'falafel', 'carrot cake', 'cannoli']
['pizza', 'falafel', 'carrot cake', 'ice cream']

如果不用切片赋值，直接将my_food赋值给friend_foods会怎样？即这样

my_food=['pizza','falafel','carrot cake']
friend_foods = my_food
my_food.append('cannoli')
friend_foods.append('ice cream')
print(my_food)
print(friend_foods) 

会输出

['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

为什么会这样呢？

这里my_foods赋给friends_foods，不是将my_foods副本存到f那，实际上这两个变量指向同一个列表(可以理解为friend_food只是my_food起别名),所以不管通过哪个修改都会影响最终的结果

元组

元组英文名叫tuple。
值不可被修改的列表叫元组，列表用[],元组用()，对元素数据修改时会报错

point = (200,50)

定义一个空元组

t = ()

如果元组只有一个元素如(1)
如果你像t = (1)这样定义则不能达到效果，最后显示t是个数。
是因为()可以是运算时的小括号，这里产生了歧义。
所以当元组只有一个元素的时候，要在后面加个英文逗号 , 以示他是个元组。t = (1,)
此处加上廖雪峰的代码例子

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

不是说tuple内不可变吗？
tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
其实就是C语言内const放在*前后的问题
const int * p = 100，100这个值不可改变，但p这个指针指向可变
int * const p = 100,p指向不可变，但100值可变
其他与列表一样，略过。
结束第三章的学习，撒花~

字典

字典使用{}，具体语法请看下面代码实例

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

'color'是字典的键，‘green’是'color'这个键对应的值，这样的对应叫为键值对

不同键值对之间要用逗号,分隔开

访问

访问整个字典时只需print(字典)

访问字典值时只需print(字典[‘键’])

添加键值对

**语法：**原字典[‘想加的键’] = ‘想加的值’

alien = {'color':'green','points':5}
alien['x'] = 0
alien['y'] = 25
print(alien)

输出为：

{'color': 'green', 'points': 5, 'x': 0, 'y': 25}

因此可以先搞一个空字典，之后再添加

修改

alien['x'] = 0即可

删除键值对

**语法：**del 字典名[‘键’]

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

输出效果为

{'color': 'green', 'points': 5}
{'points': 5}

可通过两种方法检验键是否存在
假如说要查找Thomas在不在dict这个字典里
1.in方法如'Thomas' in dict
2.get()方法，如果键不存在，返回None
eg.dict.get(Thomas)，返回值可以修改为其他值，如-1
dict.get('Thomas',-1)

遍历字典

1.遍历键值对

user_0={
    'username':'efermi',
    'first':'ebrico',
    'last':'fermi',
}
for key,value in user_0.items():
    print("\nKey:"+key)
    print("Value:"+value)

输出效果为:

Key:username
Value:efermi

Key:first
Value:ebrico

Key:last
Value:fermi

items()函数对象为一个字典，返回值为键值对列表

for循环一次将每个键值对存储到指定的两个变量key和value中

ps:我们从此也应该知道键的英文名为key，值的英文名为value

2.遍历字典中的键

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

输出效果为：

Jen
Sarah
Edward
Phil

keys()函数对象为一个字典，返回值为包含该字典所有键的一个列表

不用keys函数时，默认遍历所有键

如果想按顺序遍历字典中的所有键，则可以在for循环处 for name in sorted(fav_lan.keys())

对dictionary.keys()的结果调用了函数sorted()

3.遍历字典中的值

fav_lan = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
}
for lan in fav_lan.values():
    print(lan.title())

输出效果为：

Python
C
Ruby
Python

values()函数对象为一个字典，返回值为包含该字典所有值的一个列表

但python重复了两次，如果我不想输出重复的呢？

set()函数！

通过对包含重复元素的列表调用set()，可找到列表中独一无二的元素

fav_lan = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
}
for lan in set(fav_lan.values()):
    print(lan.title())

输出效果为：

C
Python
Ruby

set

set和dictionary类似，都是一组key的集合，不过key不能重复
以下的>>>行是输入行，没有的则是输出

>>>s = set([1,2,3])
>>>s
{1, 2, 3}

>>>s = set([1,1,2,2,3,3,4,5])
>>>s
{1, 2, 3, 4, 5}

可见重复值自动被过滤。
可通过set中的add方法添加元素。语法：set.add(key)

>>>s.add(7)
>>>s
{1, 2, 3, 4, 5, 7}

set中的remove方法删除元素。语法：set.remove(key)

>>>s.remove(2)
>>>s
{1, 3, 4, 5, 7}

set可以进行数学上的交并集运算

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

开始套娃（嵌套）

字典列表

列表元素是字典的列表

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}

但如果我想弄很多个外星人呢？不可能一个一个输入把

请看下面的程序实例

aliens = []
for alien_number in range(30):
    new_alien = {'color':'green','points':5,'speed':'slow'}
    aliens.append(new_alien)
    
# 显示前五个外星人
for alien in aliens[:5]:
    print(alien)

# 显示创建了多少个外星人
print("Total number of aliens: "+str(len(aliens)))

先创建一个空列表，range()返回一系列数字，唯一的用途是告诉我们循环多少次

len()返回列表元素个数

str()将…转化为字符型

列表字典

存储着列表的字典

pizza = {
    'crust':'thick',
    'toppings':['mushrooms','extra cheese']
}
print("You ordered a "+pizza['crust']+"-crust pizza"+"with the following toppings:")
for topping in pizza['toppings']:
    print("\t"+topping)

输出效果为：

You ordered a thick-crust pizzawith the following toppings:
	mushrooms
	extra cheese

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

字典嵌套字典

也就那样不写代码了

提醒一点，字典内部结构最好一样，这样

用户输入和while循环

input()函数

name = input("Tell me your name: ")
print(name)

终端会显示Tell me your name:，然后等待用户输入,输入Horace，此时Horace被存入name这个变量中，print(name)即可打印出Horace

语法：a = input(提示内容)，显示提示内容，将用户输入的内容存入name中，会将提示内容理解为字符串存入

prompt = "If you tell us who you are, we can personalize the message you see."
prompt += "\nWhat's your first name?"

name = input(prompt)
print("\nHello,"+name+"!")

+=运算符在存储prompt的字符串末尾附加一个字符串，类似于C++的两个string类型字符串相加

int()函数

将字符型的数字转换为数值

但int型函数会将用户输入的内容理解为数值

age = input("How old are you：")
age = int(age)
age>=18

How old are you：21

Out[1]:

True

将input输入的字符型数字用int()转换之后即可跟18比较

while循环

for循环用于针对集合中的每个元素的一个代码块，而while循环不断的运行，直到条件不满足

current_number = 1
while current_number <= 5:
    print(current_number)
    current_number += 1

输出效果为

1
2
3
4
5

prompt = "Enter some words expected 'quit'："
message = ""
# 将message设置为空字符串，让python初次有东西检查
while message!= 'quit':
    message = input(prompt)
    print(message)

以下为输出效果

Enter some words expected 'quit'：words
words
Enter some words expected 'quit'：shit
shit
Enter some words expected 'quit'：oh no
oh no
Enter some words expected 'quit'：quit
quit

prompt为每次循环进行会输出的提示内容，只要我们输入的不是quit，程序就不会停止

但如果我不想打印那个quit呢，加个if条件句，对message的内容进行检查即可

break跳出循环&&continue

跟C一样不讲

利用while循环处理列表和字典

列表中移动元素

unconfirmed_users = ['alice','brian','candace']
confirmed_users = []
while unconfirmed_users:
    current_user = unconfirmed_users.pop()
    
    print("Verifying user:"+current_user.title())
    confirmed_users.append(current_user)
    
print("\nThe following users have been confirmed:")
for confirmed_user in confirmed_users:
    print(confirmed_user.title())

输出效果为

Verifying user:Candace
Verifying user:Brian
Verifying user:Alice

The following users have been confirmed:
Candace
Brian
Alice

可以删除包含特定值的所有列表元素

pets = [...]
while 'cat' in pets:
	pets.remove('cat')
	
print(pets)

可以用来填充字典

response ={}
# 创建一个空字典
active = True

while active:
    name = input("What's your name?")
    mountain = input("Which mountain would you like to climb?")
    
    response[name] = mountain
    # 名字是键，回答为值，将其存入字典中，妙啊
    repeat = input("another one?(yse/no)")
    if repeat == 'no':
        active = False

print("Results:")
for name,mountain in response.items():
    print(name + " would like to climb "+mountain+".")

输出效果为：（问号后的是用户输入内容）

What's your name? Horace
Which mountain would you like to climb? Hua
another one?(yse/no) yes
What's your name? Tom
Which mountain would you like to climb? Song
another one?(yse/no) no
Results:
Horace would like to climb Hua.
Tom would like to climb Song.

for循环处理起来比较容易