基础知识

一、Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

二、Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

三、四种不同的数值类型

• int（有符号整型）：在 64 位系统上，取值范围为 [-2^63 ~ 2^63-1]；
• long（长整型，可代表八进制和十六进制）：没有指定位宽，即没有限制长整型数值的大小；
• float（浮点型）：带有小数的数字，占 8 个字节（64 bit），其中 52 位表示底，11 位表示指数，剩下的一位表示符号；
• complex（复数）：由实数部分和虚数部分组成，一般形式为 x + yj，其中 x 为实数部分，y 为虚数部分。

四、变量赋值

赋值语句包含一个变量名，一个等号（称为赋值操作符），以及要存储的值。Python 中的变量不需要声明数据类型，变量的类型是指内存中被赋值对象的类型。

五、变量赋值传递时的引用和拷贝

Python 赋值过程中不明确区分拷贝和引用时，一般对静态变量（不可变数据变量）的传递为拷贝，对动态变量（可变数据变量）的传递为引用。

## Tuple 与 Set
## Tuple 元祖与列表类似，不同之处在于元祖的元素不能修改。可以使用小括号创建元祖，里面的元素可以重复
## Set 是一个无序的不重复元素序列。可以使用大括号创建集合，往里添加的元素将会去重输出，使用 set() 可以转换其他数据类型为集合。
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 3, 4, 5, 6, 7)
print("tup1[0]:", tup1[0])
print("tup2[1:5]:", tup2[1:5])

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)
print(set(tup2))

## 复数
aa = 123-12j
print(aa.real)
print(aa.imag)

## 拷贝（传值）与引用（传址）
dict = {'a': [1, 2, 3, 4, 5], 'b':2}
x = dict['a']
for i in range(5):
    x[i] = 0
print(dict)

x = dict['b']
x = x+3
print(dict)

控制流

一、操作符

• 比较操作符：==，!=，<，>，<=，>=，
• 布尔操作符：and，or，not

二、控制流语句
控制流语句会根据判断条件是 True 还是 False，来决定后面执行什么。有时候判断条件为某些特定值，如 0，0.0 和 ''（空字符串）等价于 False，其他值等价于 True

• if-else
• while（只要 while 语句的条件为 True，while 子句的代码就会一遍又一遍地执行），可结合 break，continue，让执行提前跳出 while 循环子句.
  • break 是跳出整个循环
  • continue 是跳出本次循环并重新跳回到循环开始处

## while 循环
name = ''
while name != 'davidac':
    print('Please type your name.')
    name = input()
print('Thank you!')

while True:
    print('Who are you?')
    name = input()
    if name != 'davidac':
        continue
    print('Hello, davidac. What is the password?')
    password = input()
    if password == '123':
        break
print('Access granted.')

函数

一、def 语句

def 语句滞后的代码块是函数体，在函数调用时执行，而不是在函数第一次定义时执行。在代码中，函数调用就是函数名后跟上括号，如果需要参数，则把参数写在括号内。

二、返回值和 return 语句

return 语句指定应该返回什么值，可以返回特定值，也可以将返回值作为参数传递给另一个函数调用。

三、None 值

None 是 NoneType 数据类型的唯一值，必须大写首字母 N。对于没有 return 语句的函数定义，Python 都会在末尾加上 return None。如果函数里只有 return 关键字本身，那么就返回 None。

四、关键字参数

大多数参数是由他们在函数调用中的位置来识别的，但关键字参数是由调用时加在它们前面的额关键字来识别的。比如 print('cats', 'dogs', 'mice', sep=',')

五、局部和全局变量

在被调用函数内赋值的变元（参数赋值的变量）和变量，处于该函数的「局部作用域」，称为局部变量，在所有函数之外赋值的变量，属于「全局作用域」，被称为全局变量。

• 全局作用域的代码不能使用任何局部变量
• 局部作用域可以访问全局变量
• 一个函数的局部作用域中的代码不能使用其他局部作用域中的变量
• 避免局部变量与全局变量或其他局部变量同名
• 在一个函数中，一个变量要么总是全局变量，要么总是局部变量

六、global 语句

使用 global 语句，可以将函数内的变量修改为全局变量。

七、异常处理

错误可以由 try 和 except 语句来处理，那些可能出错的语句被放在 try 子句中，如果错误发生，程序执行就转到接下来的 except 子句开始处。此处若在 try 子句中的代码导致一个错误，会抛出 except 子句输出的错误信息，并继续往后执行。

列表与字典

一、列表操作

• 列表连接和列表复制：+，*
• 从列表删除值：使用 del 语句将列表中下标处的值删除，其后面的所有值，都将向前移动一个下标。
• 使用循环和 append() 将元素追加到空列表里
• 常用的 for 循环：[i for i in range(len(somelist))]
• 判断一个值是否在列表中：in 和 not in
• 多重赋值技巧：变量的数目和列表的长度必须严格相等

二、列表方法

• index()：判断一个值是否在列表中，就返回它的下标，如果该值不存在，就报 ValueError
• append()：将参数添加到列表末尾
• insert()：第一个参数是新值的下标，第二个参数是要插入的新值
• remove()：将列表中的值，若该值不在列表中，则报 ValueError，若该值在列表中出现多次，只会删除第一个。跟 del 语句相比，如果知道想要删除的值，则使用 remove()
• sort()：对数值或字符串的列表进行排序，同样不能写成 spam = spam.sort()。

三、元祖
元祖数据类型几乎与列表数据类型一样，主要区别在于，元祖是不可变的，元祖不让它们的值被修改、添加或删除。如果元祖中只有一个值，可以在括号内该值的后面跟上一个逗号。如 ('hello',)

四、字典方法

• keys()：返回字典的键
• values()：返回字典的值
• items()：返回字典的键-值对（元祖格式）
• 多重赋值：[k + ', ' + str(v) for k, v in spam.items()]
• get()：有两个参数，一是要取的键，二是该键不存在时的备用键，如 str(picnicItem.get('cups', 0))

## 使用列表
catNames = []
while True:
    print('Enter the name of cat' + str(len(catNames)) + '(Or enter nothing to stop.):')
    name = input()
    if name == '':
        break
    catNames.append(name)
print('The cat names are:')
for name in catNames:
    print(' ' + name)

## 常用列表 for 循环（推导式）
catList = [str(i) + '_' + catNames[1] for i in range(len(catNames))]
print(catList)

## 多重赋值
cat = ['fat', 'black', 'loud']
size, color, disposition = cat

## append() 和 insert() 的返回值为 None
cat_spam = catList.append('Akira')
print(cat_spam)

## remove() 和 del
spam = ['cat', 'bat', 'rat', 'cat', 'hat', 'cat']
spam.remove('cat')
del spam[1]
spam

字符串操作

一、isX 字符串方法

• isalpha()：如果字串符只包含字幕，并且非空，返回 True
• isalnum()：如果字符串只包含数字和字母，并且非空，返回 True
• isdecimal()：如果字符串只包含数字字符，并且非空，返回 True
• isspace()：如果字符串只包含空格、制表符和换行，并且非空，返回 True

二、字符串连接和分割

• join()：是在一个字符串上调用，参数是一个字符串列表，如 ','.join(['cats', 'rats', 'bats'])
• split()：针对一个字符串，参数为分割字符，返回一个字符串列表

三、对齐

• rjust()/ljust()/center()：第一个参数是一个整数长度，用于对齐字符串，默认为空格

四、删除空白字符

• strip()：默认删除字符串头尾的空白字符，若传入字符串作为参数，则在字符串两端删除出现 a、m、p 和大写 S，字符的顺序并不重要，strip('ampS') 与 strip('mapS')，strip('Spam') 效果一样。

## 填充字符
'Hello'.rjust(10, '-')
'Hello'.center(20, '*')

## 删除空白字符
spam = 'SpamSpamBaconSpamEggSpamSpam'
spam.strip('Spma')

文件读写

一、文件路径

• os.getcwd()：获取当前工作目录
• os.makedirs()：创建新文件夹
• os.path.abspath(path)：将相对路径转换为绝对路径的简便方法，返回参数的绝对路径的字符串
• os.path.relpath(path, start)：将返回从 start 路径到 path 的相对路径的字符串
• os.path.dirname(path)：返回最后一个斜杠之前的所有内容
• os.path.basename(path)：返回最后一个斜杠之后的所有内容
• str.split(os.path.sep)：返回一个列表，包含该路径的所有部分
• os.path.getsize(path)：返回 path 参数中文件的字节数
• os.listdir(path)：返回文件名字符串的列表

二、检查路径有效性

• os.path.exists(path)：判断所指的文件或文件夹是否存在
• os.path.isfile(path)：判断是否文件
• os.path.isdir(path)：判断是否目录/文件夹

三、文件读写过程

三个步骤：

1. 调用 open() 函数，返回一个 File 对象。
2. 调用 File 对象的 read() 或 write() 方法
3. 调用 File 对象的 close() 方法，关闭该文件

• open() 需要指明读写模式
  • r（读），r+（可读可写），若文件不存在，均会报错不创建。
  • w（写），w+（可读可写），两者都会将文件内容清零，以 w 方式打开，不能读出。
  • a（追加），a+（可读可写）

• read()，readline() 与 readlines()

  • read()：从文件当前位置起读取 size 个字节，若无参数 size，则表示读取至文件结束为止，它范围为字符串对象。
  • readline()：每次读出文件的一行内容。
  • readlines()：从文件获得一个字符串列表，列表的每个字符串就是文本的每一行。

• write()

对文件对象（可写模式）写入内容，在读取或写入文件后，需要调用 close() 方法，这样在下次读取时才能查看到新写入的内容。

## 路径方法
import os
print(os.getcwd()) ## /Users/davidaclee/OneDrive/Code/python/practice
print(os.path.relpath('/Users/davidaclee/OneDrive/', '.'))
print(os.path.dirname(os.getcwd()))  ## /Users/davidaclee/OneDrive/Code/python/practice
print(os.path.basename(os.getcwd())) ## practice

calcFilePath = '/usr/local/hadoop/apache-hive-3.1.1-bin'
calcFilePath.split(os.path.sep)

print(os.path.getsize(calcFilePath))
print(os.listdir(calcFilePath))

totalSize = 0
for filename in os.listdir(calcFilePath):
    if os.path.isfile(os.path.join(calcFilePath, filename)) == True:
        totalSize = totalSize + os.path.getsize(os.path.join(calcFilePath, filename))
print(totalSize)

调试

一、抛出异常

抛出异常相当于是说：”停止运行这个函数中的代码，将程序执行转到 except 语句“。抛出异常使用 raise 语句，并对 Exception 函数进行调用，传递给 Exception 函数的字符串，作为报错信息。如果没有 try 和 except 语句覆盖抛出异常的 raise 语句，该程序就会崩溃，并显示异常的出错信息。

except Exception as err 如果 try 的子句返回一个 Exception 对象，这条语句就会将它保存在名为 err 的变量中，再使用 str(err) 将它转换成字符串，得到自定的出错信息。

二、断言

断言相当于是说：”我断言这个条件为真，如果不为真，程序中什么地方就有一个缺陷“。条件不成立，程序也不一定报错，但会让程序输出跟预期不一致的结果。所以通过这样快速的失败，能减少为了排查时间。

三、日志

记日志是一种很好的方式，可以理解程序中发生的事，以及事情发生的顺序。Python 的 logging 模块使得你很容易创建自定义的消息记录，并列出你指定的任意变量当时的值。另一方面，确实日志信息表明有一部分代码被跳过，从未执行。

虽然用 print() 也能输出每一个步骤的结果，但调试完成后，需要花很多时间从代码中清楚每条调试结果的 print() 调用，甚至有可能删除一些必要的 print() 调用。日志消息的好处是，可以随心所欲地在程序中加日志，随后只要调用一次 logging.disable(logging.CRITICAL)，就可以禁止日志。

四、日志级别

• DEBUG - logging.debug()，最低级别，用于小细节，在诊断问题时才会关心这些消息
• INFO - logging.info()，用于记录程序中一般事件的信息，或确认一切工作正常
• WARNING - logging.warning()，用于表示可能的问题，它不会阻止程序的工作，但将来可能会
• ERROR - logging.error()，用于记录错误，它导致程序失败
• CRITICAL - logging.critical()，最高级别，用于表示致命的错误，它导致或将要导致程序完全停止工作

## 抛出异常

def boxPrint(symbol, width, height):
    if len(symbol) != 1:
        raise Exception('Symbol must be a single character string.')
    if width <= 2:
        raise Exception('Width must be greater than 2.')
    if height <= 2:
        raise Exception('Height must be greater than 2.')
    print(symbol * width)
    for i in range(height - 2):
        print(symbol + (' ' * (width -2)) + symbol)
    print(symbol * width)

for sym, w, h in (('*', 4, 4), ('0', 20, 5), ('x', 1, 3), ('ZZ', 3, 3)):
    try:
        boxPrint(sym, w, h)
    except Exception as err:
        print('An exception happened: ' + str(err))
        
## 断言
podBayDoorStatus = 'open'
assert podBayDoorStatus == 'open', 'The pod bay doors need to be "open".'
# podBayDoorStatus = "I'm sorry, Dave. I'm afraid I cant't do that."
# assert podBayDoorStatus == 'open', 'The pod bay doors need to be "open".'

## 日志
import logging
logging.basicConfig(level = logging.DEBUG, format = '%(asctime)s - %(levelname)s - %(message)s')
logging.debug('Start of program')

def factorial(n):
    logging.debug('Start of factorial(%s)' % (n))
    total = 1
    for i in range(n + 1):
        total *= i 
        logging.debug('i is '+ str(i) + ', total is ' + str(total))
    logging.debug('End of factorial(%s)' % (n))
    return total

print(factorial(5))
logging.debug('End of program')

## 禁用日志
import logging
logging.basicConfig(level=logging.INFO, format = '%(asctime)s - %(levelname)s - %(message)s')
# logging.critical('Critical error! Critical error!')
# logging.critical('Critical error! Critical error!')
logging.error('Error! Error!')