Python 3 语法笔记

单引号和双引号嵌套使用可以有效避免转义带来的麻烦：

"this is 'a' String"
'this is also "a" String'
'this is 'a'nother String' #你能看到 a 的颜色不对
"this is also "a"nother String" #你看，a 的颜色又不对

三引号会包含介于其中的所有换行，包括三引号自身带来的换行：
```
string = """
ab
c
"""
//string = '\nab\nc\n'
```
Python 的变量名可以用中文。
print() 函数可以同时接受很多个不同类型参数，用逗号 , 分隔。会一个一个的打印，输出的句子中不同元素间默认使用空格分隔。
字符串能容纳一定长度的字符。元组和列表可以容纳若干个一切类型的元素。字典接受若干个键值对，键的类型相同，值的类型相同。字符串用 ''、""、''' '''、""" """ 包括，元组用 () 包括，列表用 [] 包括，字典用 {} 包括。此外还有一种容器，内容不能重复，它的名字叫做集合，也用 {} 包括。以上容器内部的元素之间用逗号分隔。
字符串可以插值。我使用插值这个词，是因为这个定义在 Swift 中常见，英文叫 string interpolation，我个人觉得在中文中“插值”要比“格式化”更易理解。在 C 中经常在scanf()和printf()函数中使用，在 Python 中也有类似的用法，不过其实还有更加好用的format()函数：
```
name = 'Houston Duane'
age = 20
#插值方法一：使用format()函数
string1 = "My name is {} and I'm {} years old."
print(string1.format(name,age))
#插值方法二：使用格式化符号
string2 = "My name is %s and I'm %d years old."
print(string2 % (name,age))
```
从上面可以看出，format()函数会在花括号的位置无脑替换内容，格式化符号则需要小心选取合适的变量类型 (%s代表字符串，%d代表整数)。因此，在通常使用上，format()函数要更好用一些。但是格式化符号也有自己的优势，它可以更进一步的对插值内容进行格式化，例如固定宽度、前面填0、使用八进制和十六进制、使用科学技术法等。

字符串、列表和元组的读取和拼接：

example_str = '我是字符串'
example_tuple = ('我','是','元','组')
example_list = ['我','是','列','表']

#取容器中的单个元素
#正序的时候下标从0开始递增
print(example_str[2]) #字
print(example_tuple[2]) #元
#逆序的时候下标从-1开始递减
print(example_list[-1]) #表
print(example_str[-2]) #符

#取容器的子集
#print(example_str[a:b:c]) a是开始下标，b是结束下标的下一位，c是步长及方向
#c的默认值是1
#a的默认值看c，如果c为正，则a默认为0；如果c为负，则a默认为-1
#b的默认值和c的符号相同，绝对值是len(example_str)
#若a,b,c有省略则按照规则填充默认值
#明确首尾
print(example_list[2:4]) #['列', '表']
print(example_tuple[1:3]) #('是', '元')
print(example_str[-1:-3]) # $打印空字符，因为[-1:-3:1]不合法
print(example_list[-1:0:]) #[] $打印空列表，因为[-1:0:1]不合法
print(example_str[-1:-3:-1]) #串符 $倒序的步长必须显式指出
print(example_list[-1:0:-1]) #['表', '列', '是'] $虽然看起来不合法，但其实合法
#首尾有省略
print(example_list[-2:]) #['列', '表']
print(example_str[2:]) #字符串
print(example_list[:2]) #['我', '是']
print(example_str[:-1:]) #我是字符
#特殊步长
print(example_tuple[::-1]) #('组', '元', '是', '我') $逆序输出
print(example_str[::2]) #我字串 $步长取2的意思是正序每2位取1位
print(example_list[1:3:2]) #['是']
print(example_str[-1:-5:-3]) #串是 $步长取-3的意思是逆序每3位取1位
print(example_tuple[-1::-2]) #('组', '是')

#元组的拼接
a = (2,3,1)
b = (4,2,6)
c = a + b
print(c) #(2, 3, 1, 4, 2, 6)

字符串和元组只可以做读、切片和拼接操作；而列表、集合、字典可以做到读、切片、扩容、修改和删除。元组、列表可以转化为集合，转化过程中会去重，得到的集合里面的排列顺序不一定与原来容器里面的相同。反过来把集合转为列表或者元组，顺序则按照集合里的顺序。

#列表的扩容
example_list.append(example_tuple)
print(example_list) #['我', '是', '列', '表', ('我', '是', '元', '组')]
#列表的修改
example_list[1] = '不是'
print(example_list) #['我', '不是', '列', '表', ('我', '是', '元', '组')]
#列表的删除
example_list.pop(0)
print(example_list) #['不是', '列', '表', ('我', '是', '元', '组')]

#将列表转为集合，观察去重和乱序
example_list.append('不是')
print(example_list) #['不是', '列', '表', ('我', '是', '元', '组'), '不是']
example_set = set(example_list)
print(example_set) #{('我', '是', '元', '组'), '不是', '表', '列'}

#此时把集合再转为元组的时候，顺序则严格按照原集合里的顺序排列
example_tuple = tuple(example_set)
print(example_tuple) #(('我', '是', '元', '组'), '不是', '表', '列')

#向集合中添加元素，顺序依旧会乱
example_set.add(3.14)
print(example_set) #{('我', '是', '元', '组'), '不是', 3.14, '列', '表'}

#字典的扩容
example_dict = {
    'name':'Houston', 
    'job':'iOS Developer', 
    'company':'ByteDance Shenzhen'
}
example_dict['section']='EE'
print(example_dict) 
'''{
'name': 'Houston', 
'job': 'iOS Developer', 
'company': 'ByteDance Shenzhen', 
'section': 'EE'
}'''
#字典的修改
example_dict['name']='Houston Duane'
print(example_dict) 
'''{
'name': 'Houston Duane', 
'job': 'iOS Developer', 
'company': 'ByteDance Shenzhen', 
'section': 'EE'
}'''
#字典的删除
example_dict.pop('company')
print(example_dict) 
'''{
'name': 'Houston Duane', 
'job': 'iOS Developer', 
'section': 'EE'
}'''

#字典中后出现的键值对会替换掉前面相同键的值
example_dict = {4:'0100', 3:'0011', 3:'0x3', 2:'0x2'}
print(example_dict) #{4: '0100', 3: '0x3', 2: '0x2'}

if-elif-else 语句：

if 'name' in example_dict and 'company' in example_dict:
    print('I know %s works for %s.' 
       % (example_dict['name'], example_dict['company']))
elif 'name' in example_dict and \
     'company' not in example_dict and \
     'section' in example_dict:
    print("I don't know where %s works, but I know %s works in %s." 
       % (example_dict['name'], example_dict['name'], example_dict['section']))
else:
    print("I don't know nothing.")
    
#I don't know where Houston Duane works, but I know Houston Duane works in EE.

if 可以搭配 0 个或多个 elif 和 0 个或 1 个 else 来组成条件语句。

如果需要很多很多个elif的话，其实可以用字典来简化条件：

new_iPhone_price = {
    'iPhone XR (64GB)': 6_499,
    'iPhone XR (128GB)': 6_999,
    'iPhone XR (256GB)': 7_899,
    'iPhone XS (64GB)': 8_699,
    'iPhone XS (256GB)': 10_099,
    'iPhone XS (512GB)': 11_899,
    'iPhone XS Max (64GB)': 9_599,
    'iPhone XS Max (256GB)': 10_999,
    'iPhone XS Max (512GB)': 12_799
}
print(new_iPhone_price['iPhone XR (128GB)']) #6999
print(new_iPhone_price.get('iPhone XR (64GB)')) #6499
#可以自定义当键不存在时返回的默认值
print(new_iPhone_price.get('iPhone X (64GB)', 'Not On Sale')) #Not On Sale

Python 中有in、not、and、or、range()可以帮助使用条件语句和循环语句。a in b代表a在b里。not and or分别代表逻辑上的非、与、或。range()则用于表明一个范围：

#默认输出键
for key in new_iPhone_price:
    print (key)
'''
iPhone XR (64GB)
iPhone XR (128GB)
iPhone XR (256GB)
iPhone XS (64GB)
iPhone XS (256GB)
iPhone XS (512GB)
iPhone XS Max (64GB)
iPhone XS Max (256GB)
iPhone XS Max (512GB)
'''
#可以明确输出键还是值
for key in new_iPhone_price.keys():
    print (key)
'''
iPhone XR (64GB)
iPhone XR (128GB)
iPhone XR (256GB)
iPhone XS (64GB)
iPhone XS (256GB)
iPhone XS (512GB)
iPhone XS Max (64GB)
iPhone XS Max (256GB)
iPhone XS Max (512GB)
'''
for val in new_iPhone_price.values():
    print (val)
'''
6499
6999
7899
8699
10099
11899
9599
10999
12799
'''
#当然可以输出键值对
for key,val in new_iPhone_price.items():
    print ("%s: %d" % (key,val))
'''
iPhone XR (64GB): RMB 6499
iPhone XR (128GB): RMB 6999
iPhone XR (256GB): RMB 7899
iPhone XS (64GB): RMB 8699
iPhone XS (256GB): RMB 10099
iPhone XS (512GB): RMB 11899
iPhone XS Max (64GB): RMB 9599
iPhone XS Max (256GB): RMB 10999
iPhone XS Max (512GB): RMB 12799
'''

函数的定义：

def func1():
    print('Hello from function 1.')
    
def func2(par):
    print('Hello from function 2 who accepts an argument {}'.format(par))
    
def func3(par='DEFAULT'):
    print('Hello from function 3 who '
          'accepts an argument {} if given and offers '
          'a default argument.'.format(par))
    
def func4(par1, par2='DEFAULT'):
    print('Hello from function 4 who '
          'accepts a first argument {} and offers '
          'a second default argument {} if not given.'.format(par1,par2))

func1()
func2('Potato')
func3()
func3('Tomato')
func4('Mango')
func4('Mosquito','Hero')
'''
Hello from function 1.
Hello from function 2 who accepts an argument Potato
Hello from function 3 who accepts an argument DEFAULT if given and offers a default argument.
Hello from function 3 who accepts an argument Tomato if given and offers a default argument.
Hello from function 4 who accepts a first argument Mango and offers a second default argument DEFAULT if not given.
Hello from function 4 who accepts a first argument Mosquito and offers a second default argument Hero if not given.
'''

Python 文件读写常常用 with ... as ...的语句：
```
with open('notAFile.csv', 'rw', encoding='utf-8') as f:
    #这个时候文件已经被成功打开，文件的使用权交给了f这个对象
    content.list = f.readlines()

#这个时候文件被成功地关闭，文件的使用权被释放，f不再操纵这个文件
```
从我上面的解析中你也能看懂，往常的 C++ 的写法是用 fstream 来操作文件，在文件读取之前要“打开”这个文件，在文件操作完毕之后还一定要“关闭”这个文件。而在 Python 中，你会发现没有任何 open和close函数，而是采用with ... as ...得到的句柄来代替我们完成这件事情。这样妈妈再也不用担心我忘记写close函数啦！