《Python快速编程上手让繁琐工作自动化》学习总结--第一部分 python编程基础

 print('For your ' + \
      'infomation')
 # For your infomation
 
 msg1 = '''维护
   秩序！
 '''
 """
 维护
     秩序！
     
 """
 print(msg1)
 msg2 = """ni
   w
     ****"""
 print(msg2)
 """
 ni
     w
         ****
 """

(2) print()：

将()内的字符串显示到屏幕

关键字参数有可选变元end、sep：

end: 参数末尾打印什么
sep: 参数之间打印什么

print("a","b","c",sep=',',end='...')  # a,b,c...

(3) input()：

等待用户键盘输入一些文本，返回值是字符串

(4) len()：

求值一个整型，()中字符串字符的个数

(5) str()、int()、float()：

将传入值变为字符串、整数、浮点数形式。

不能求值为整数的值传入int()会报错，如int('99.9')、int('one')都不行。

int(7.9) --> 7

第2章控制流

2.1 布尔值(True/False)

大小写不能错误！不能做为变量名。

2.2 比较操作符、布尔操作符

比较操作符的求值为True或False.

比较操作符	说明	比较操作符	说明
==	等于（用于所有数据类型值）	<、>	小于、大于（仅用于整型、浮点型值）
!=	不等于（用于所有数据类型值）	<=、>=	小于等于、大于等于（仅用于整型、浮点型值）

布尔操作符	说明	布尔操作符	说明
and	二元布尔操作符，两个为真结果为真。True and False --> False	not	一元布尔操作符，not True --> False
or	二元布尔操作符，一个为真结果为真。True or False --> True

操作顺序：算数和比较操作符求值 --> not 操作符 --> and 操作符--> or 操作符。

2.3 控制流语句

(1) if语句

 if 条件(求值为True或False的表达式):
     代码块
 if 条件(求值为True或False的表达式):
     代码块1
 else:
     代码块2
 if 条件1(求值为True或False的表达式):
     代码块2
 elif 条件2(求值为True或False的表达式):
     代码块2
 elif ...:
   ...
 else:
     代码块n

如果有一系列elif语句，仅有一条或0条或执行，一旦一个语句条件为True，其他elif语句会自动跳过。

(2) while循环语句（break、continue）：

while 条件(求值为True或False的表达式):
     代码块

break：提前跳出while循环，接着while后的语句执行。

continue：用于循环内部，马上调回循环开始，重新对循环条件求值。

(3) for循环、range()函数：

for循环和while循环可以做同样的事，但for循环更简洁。

range的三个参数，包含起始值、不包含终止值。

 for 变量 in range(起始、停止、步长)：
     代码块 
 -------------------------
 for i in range(4):        # 0 1 2 3
   print(i)
 for j in range(4,7):      # 4 5 6
   print(j)
 for k in range(1,9,3):    # 1 4 7
   print(k)
 for h in range(10,1,-3):    # 10  7 4
   print(h)

2.4 导入模块

 import 模块1,模块2
 -------------------------
 import random
 j = random.randint(1,100) # 随机取1-100之间的整数，包含1和100
 =========================
 from 模块1 import *
 -------------------------
 from random import *
 j = randint(1,100) # 可直接调用函数，不写模块名前缀，但可读性不如前者

2.5 sys.exit():提前结束程序

sys.exit()可以让程序终止会退出，在sys模块中。

 import sys
 while True:
   print('type exit to exit.')
   response = input()
   if response == 'exit':
     sys.exit()
   print('You typed ' + response +'.')

第3章函数

3.1 def语句和参数

传入函数的变量在程序结束后会被丢弃！

 def hello(变元/变量):
   代码块
   return 返回值/表达式

3.2 None值（没有值、NoneType数据类型）

print()函数的返回值就是None。

3.3 局部和全局作用域

全局作用域的代码不能使用任何局部变量
局部作用域可以访问全局变量
一个函数的局部作用域中代码不能使用其他局部作用域中的变量
不同作用域可以使用相同的名字命名不同的变量。
不要过度依赖全局变量，当程序很大时，难以追踪变量赋值的缺陷位置

3.4 global语句

如果需要在一个函数内修改全局变量，就使用 global 语句。

 def spam():
   global eggs
   eggs = 100
 eggs = 'global'
 print(eggs)     # global
 spam()
 print(eggs)     # 100

判断一个变量是局部变量还是全局变量：

全局变量：变量在全局作用域中使用、在一个函数中有针对该变量的global语句、在函数中没有针对该变量的global语句，也有用于赋值语句。
局部变量：在函数中没有针对该变量的global语句，且用于赋值语句。

3.5 异常处理 try... except...

一旦执行跳到except子句代码，就不会回到try子句。try出错代码后面的代码就不会执行。

 def spam(divideBy):
   try:
     return 43/divideBy
   except ZeroDivisionError:       # 除数为零异常
     print('Error:Invalid argument.')

第4章列表list[]

4.1 取得列表中的单个值：list[index]

通过下标index，index只能是整数，如 list[-1]、 list[0]、list[2]，不能是浮点值。

负数下标代表倒数，如-1是最后一个下标，-2是倒数第二个下标

 list = [1,3,5,6,7]
 print(list[-1],list[0],list[2])   # 7 1 5

列表可以嵌套列表。

 list = [1,3,[5,7,8],1,1,2]
 print(list[-1],list[0],list[2]) #2  1 [5,7,8]
 print(list[2][2])   # 8

4.2 切片取得子列表：list[:]

list[起始值:终止值:步长]：包含列表中起始值下标的值，但不包括终止值下标的值。

 list = [1,3,5,6,7,11,14,16,18]
 print(list[1:3])    # [3,5]
 print(list[:3])     # [1,3,5]
 print(list[7:])     # [16,18]
 print(list[1:6:2])  # [3,6,11]
 print(list[::3])    # [1, 6, 14]

4.3 len(list)函数取得列表长度、in、not in

查找值 in 查找列表：返回布尔值，值在列表中返回True
查找值 not in 查找列表：返回布尔值，值不在列表中返回True

 list = [1,3,5,6,7,11,14,16,18]
 print(len(list))    # 9
 
 for i in range(len(list)):
   print(i)

4.4 改变列表元素的值

 list = [1,3,5,6,7,11,14,16,18]
 list[0] = 99
 print(list)   # [99,3,5,6,7,11,14,16,18]

4.5 列表连接(+)、列表复制(*)、多重赋值、增强赋值

*操作符用于一个列表和一个整数。

可用列表中的值为多个变量复制，变量数量必须和列表长度严格相等，否则ValueError。

 list1,list2 = [1,2,3],[4,5,6,7]
 print(list1 + list2)    # [1, 2, 3, 4, 5, 6, 7]
 print(list1 * 3)        # [1, 2, 3, 1, 2, 3, 1, 2, 3]
 a,b,c = list1
 print(a,b,c)      # 1 2 3

赋值语句	等价语句	赋值语句	等价语句
spam += 1	spam = spam + 1	spam /= 1	spam = spam / 1
spam -= 1	spam = spam - 1	spam %= 1	spam = spam % 1
spam *= 1	spam = spam * 1

 a = 'AFDGF'
 a += "abdbf"
 print(a)  # AFDGFabdbf
 b = ['Mood']
 b *= 3
 print(b)    # ['Mood','Mood','Mood']

4.6 查找列表值的下标：index()方法

如果值不在列表中，报错ValueError.

如果值在列表中有多个，返回第一次出现的下标。

 a = ['hello','wird','hahahah','wird','hahahah']
 i1 = a.index('hello')
 print(i1)   # 0
 i2 = a.index('wird')
 print(i2)   # 1

4.7 删除列表中的值：del语句、remove()方法、pop()方法

知道下标用del，知道值用remove。

del list[index] ：删除列表中下标为index的值，index为整数，也可以切片删除。
list.remove('cat'): 删除指定的值，如果值出现多次，只删除第一次出现的。
list.pop()：删除列表最后一个元素

 list = [1,3,5,6,7,11,14,16,18]
 del list[0]
 print(list)   # [3,5,6,7,11,14,16,18]
 del list[0:3]
 print(list)   # [7,11,14,16,18]
 del list[::2]
 print(list)   # [11, 16]
 list.pop()
 print(list)   # [11]
 
 list1 = ['cat','bga','cat','cat']
 list1.remove('cat')
 print(list1)  # ['bga','cat','cat']

4.8 插入列表值：insert()、append()方法

insert()、append()方法返回值是None，列表被直接修改。

只能在列表上调用，不能在字符串等其他值调用。

append(): 将参数添加在列表末尾
insert(新值下标, 插入新值): 将新值添加在指定的下标位置

 list = ['a','b','c']
 list.append('hello')
 print(list)   # ['a','b','c','hello']
 list.insert(3,'d')
 print(list)   # ['a','b','c','d','hello']

4.9 排序列表值：sort()、reverse()方法

不能对既有数字又有字符串的列表排序，如[1,3,'a']不能排序！！

sort()：将数值或字符串的列表按照ASCII码顺序排序。先数字（字符串格式），再大写字母、再小写字母。
sort(key=str.lower)：按照字母顺序排序，同样的字母先大写再小写。排序时将所有当小写，但实际并不改变列表值。
sort(reverse = True)：将数值或字符串的列表按照ASCII码字符倒序排序。
reverse(): 将列表倒序排序。

 a = ['egg', 'a', 'A', 'Gigg', 'Zippo', '!!', '@', 'zIPPO', '112', '9', '2.3', '-3.8', '?']
 a.sort()
 print(a)   # ['!!', '-3.8', '112', '2.3', '9', '?', '@', 'A', 'Gigg', 'Zippo', 'a', 'egg', 'zIPPO']
 -----------------------------------------------
 a = ['egg', 'a', 'A', 'Gigg', 'Zippo', '!!', '@', 'zIPPO', '112', '9', '2.3', '-3.8', '?']
 a.sort(key=str.lower)
 print(a)   # ['!!', '-3.8', '112', '2.3', '9', '?', '@', 'a', 'A', 'egg', 'Gigg', 'Zippo', 'zIPPO']
 -----------------------------------------------
 a = ['egg', 'a', 'A', 'Gigg', 'Zippo', '!!', '@', 'zIPPO', '112', '9', '2.3', '-3.8', '?']
 a.sort(reverse = True)
 print(a)   # ['zIPPO', 'egg', 'a', 'Zippo', 'Gigg', 'A', '@', '?', '9', '2.3', '112', '-3.8', '!!']
 -----------------------------------------------
 a = ['egg', 'a', 'A', 'Gigg', 'Zippo', '!!', '@', 'zIPPO', '112', '9', '2.3', '-3.8', '?']
 a.reverse()
 print(a)   # ['?', '-3.8', '2.3', '9', '112', 'zIPPO', '@', '!!', 'Zippo', 'Gigg', 'A', 'a', 'egg']

4.10 字符串str、元组tuple()

字符串也可以下标取值、切片、用于for循环、len()、in操作符、not in操作符
列表元素是可变的，字符串是不可变的，字符串不能对其中一个字符重新赋值。
改变字符串的方法：切片、连接。
重新给整个列表赋值，列表的id（内存地址）是改变了的，如果不想改变只是覆写，列表内存地址不变，只能通过del将列表值一个一个元素删除，再通过append一个一个元素赋值。
元组是不可变的。值不能被修改、添加、删除。
如果元组还有一个值，要在后面加上逗号(,)，否则会被认为是个字符串类型。

 type(('hello',))    # 元组类型
 type('hello')       # 字符串类型

4.11 列表和元组类型相互转换list()、tuple()

 print(list(('abc',)))   # abc
 print(list(('abc')))    # ['a', 'b', 'c']
 print(tuple(['a','b','c']))   # ('a', 'b', 'c')

4.12 引用：copy()、deepcopy()函数

对列表或字典可变数据类型的值时，使用引用。

对于字符串、整型、元组等不可变的数据类型的值，变量保存值本身。

直接将变量a赋值给一个新变量b，b改变时，a不会改变。
直接将列表a赋值给一个新列表b，b的一个元素改变时，a也会改变。
如果不希望原列表改变，则使用a的切片赋值，或使用copy模块中的copy()、deepcopy()函数
- copy(): 深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用。
- deepcopy(): 父对象（一级目录）和子对象（二级目录）都拷贝。

 a1 = 10
 b1 = a1
 b1 = 99
 print(a1,b1)  # 10,99
 # -----------------------
 a2 = [1,2,3,4]
 b2 = a2
 b2[1] = 99
 print(a2,b2)  # [1,99,3,4]    [1,99,3,4]
 # -----------------------
 a3 = [1,2,3,4]
 b3 = a3[:]
 b3[1] = 99
 print(a3,b3)  # [1,2,3,4]    [1,99,3,4]
 # -----------------------
 a4 = {'name': 'Calhoun', 'age': 23}
 b4 = a4
 b4['age'] = 99
 print(a4, b4) # {'name': 'Calhoun', 'age': 99} {'name': 'Calhoun', 'age': 99}

copy()、deepcopy()函数

 import copy
 dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
 
 dict2 = dict1          # 浅拷贝: 引用对象
 dict3 = copy.copy(dict1)   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用
 dict4 = copy.deepcopy(dict1)  # 深拷贝
 
 # 修改 data 数据
 dict1['user'] = 'root'
 dict1['num'].remove(1)
 
 # 输出结果
 print('原字典：', dict1)
 print('赋值字典：', dict2)
 print('copy字典：', dict3)
 print('deepcopy字典：', dict4)
 
 """
 原字典： {'user': 'root', 'num': [2, 3]}
 赋值字典： {'user': 'root', 'num': [2, 3]}
 copy字典： {'user': 'runoob', 'num': [2, 3]}
 deepcopy字典： {'user': 'runoob', 'num': [1, 2, 3]}
 """

第5章字典dict{}和结构化数据

5.1 字典、dict.keys()、dict.values()、dict.items()

键（key）：字典的索引，dict.keys()方法，返回类似列表的值，但不是真正的列表，不能被修改。可用list()转化为列表。
值（value)：字典的键关联的值，dict.values()方法，返回类似列表的值，但不是真正的列表，不能被修改。可用list()转化为列表。
键-值对（item）：dict.items()方法，返回类似列表的值，但不是真正的列表，不能被修改。可用list()转化为列表。

 dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
 a1 = dict1.keys()
 b1 = dict1.values()
 c1 = dict1.items()
 print(a1, b1, c1, end='\n', sep='\n')
 print(list(a1), list(b1), list(c1), end='\n', sep='\n')
 
 """
 dict_keys(['user', 'num'])
 dict_values(['runoob', [1, 2, 3]])
 dict_items([('user', 'runoob'), ('num', [1, 2, 3])])
 
 ['user', 'num']
 ['runoob', [1, 2, 3]]
 [('user', 'runoob'), ('num', [1, 2, 3])]
 """

字典是不排序的，可以用in 或not in 查看键是否存在字典中。for dict in dict1是for dict in dict1.keys()的简写。

 dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
 a21 = 'runoob' in dict1.items()
 a22 = 'runoob' in dict1.keys()
 a22_1 = 'runoob' in dict1
 a23 = 'runoob' in dict1.values()
 print(a21, a22, a22_1, a23)   # False False False True

5.2 get()方法、setdefault()方法

get(取得值的键, 键不存在返回的备用值): 如果键存在，返回该键对应的值，否则返回备用值，默认备用值可设为0.
setdefault(检查的键, 该键不存在时设定的值):为某键设定一个默认值，但如果该键存在，则不做改变。

dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
a1 = dict1.get('num',1) 
a2 = dict1.get('num1','None') 
print(a1,a2)    # [1, 2, 3] None
dict1.setdefault('Age',45)
print(dict1)    # {'user': 'runoob', 'num': [1, 2, 3], 'Age': 45}
dict1.setdefault('user','Bob')
print(dict1)    # {'user': 'runoob', 'num': [1, 2, 3], 'Age': 45}

setdefault()可用来计算字符串每个字符出现的次数。

 msg = 'Hello,I\'m lijing.What is your name ?'
 count = {}
 for i in msg:
     count.setdefault(i, 0)
     count[i] = count[i] + 1
 print(count)
 
 """
 {'H': 1, 'e': 2, 'l': 3, 'o': 2, ',': 1, 'I': 1, "'": 1, 'm': 2, ' ': 5, 'i': 3, 'j': 1, 'n': 2, 'g': 1, '.': 1, 'W': 1, 'h': 1, 'a': 2, 't': 1, 's': 1, 'y': 1, 'u': 1, 'r': 1, '?': 1}
 """

5.3 pprint()、pformat()函数

使用pprint()、pformat()函数，需要导入pprint模块。

如果想得到显示在屏幕上的漂亮字符串，则使用pprint.pformat()，以下代码中的print(pprint.pformat(count))和pprint.pprint(count) 两者等价！

 import pprint
 msg = 'Hello,I\'m lijing.What is your name ?'
 count = {}
 for i in msg:
     count.setdefault(i, 0)
     count[i] = count[i] + 1
 f1 = pprint.pformat(count)
 pprint.pprint(count)
 
 """
 {' ': 5,
  "'": 1,
  ',': 1,
  '.': 1,
  '?': 1,
  'H': 1,
  'I': 1,
  'W': 1,
  'a': 2,
  'e': 2,
  'g': 1,
  'h': 1,
  'i': 3,
  'j': 1,
  'l': 3,
  'm': 2,
  'n': 2,
  'o': 2,
  'r': 1,
  's': 1,
  't': 1,
  'u': 1,
  'y': 1}
 """

第6章字符串操作

6.1 处理字符串

用双引号“字符串”作为开始和结束，这样字符串就可以包含单引号'。
转义符\：可以在字符串中用单引号和双引号。
原始字符串r: 通过在引号前加r使它成为原始字符串，即忽略转义字符，打印字符串中的\符号。
三重引号：多行字符串，里面不需要转义，常用于多行注释。引号、制表符、换行都是字符串一部分、代码块缩进规则不适用多行字符串。
#：单行注释。

6.2 字符串下标、切片、in、not in操作符

与列表类似。

6.3 有用的字符串方法

(1) upper()、lower()、isupper()、islower()

upper() : 返回一个新字符串，将原字符串的字母都转换为大写，非字母字符不变。没有改变原字符串！
lower() : 返回一个新字符串，将原字符串的字母都转换为小写，非字母字符不变。没有改变原字符串！
isupper() : 返回布尔值，字符串至少一个字母，且所有字母都大写，返回值为真，否则为假。
islower() : 返回布尔值，字符串至少一个字母，且所有字母都小写，返回值为真，否则为假。

(2) isX()

isalpha(): 如果字符串只包含字母，并且非空，返回 True。
isalnum(): 如果字符串只包含字母和数字，并且非空，返回 True。
isdecimal(): 如果字符串只包含数字字符，并且非空，返回 True。
isspace(): 如果字符串只包含空格、制表符和换行，并且非空，返回 True。
istitle(): 如果字符串仅包含以大写字母开头、后面都是小写字母的单词，返回 True。

 a1, a2, a3, a4, a5 = 'Add', 'Add1234', '1234.5', ' \t', 'HueW'
 print(a1.isalpha(), a1.istitle())   # True True
 print(a2.isalnum(), a2.isdecimal())   # True False
 print(a3.isalpha(), a3.isdecimal())   # False False
 print(a4.isspace())   # True
 print(a5.istitle())   # False

(3) startswith()、endswith()

startswith()：如果字符串以调用的字符串开始，返回True，否则返回False
endswith()：如果字符串以调用的字符串结束，返回True，否则返回False

 a1, a2= 'Add','HueW'
 print(a1.startswith('Ad'), a1.startswith('ad'))   # True False
 print(a2.endswith('eW'), a2.endswith('leW'))    # True False

(4) join()、split()

join(): 将字符串列表连接成一个字符串。'连接符'.join(字符串列表)
split(): 针对字符串调用，返回字符串列表。默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

 a1 = '-'.join(['cats', 'rats', 'bats'])
 print(a1) # cats-rats-bats
 a2 = a1.split('-')
 print(a2) # ['cats', 'rats', 'bats']
 a3 = "MyHHHNameHHHIsHHHJing.".split('HHH')
 print(a3) # ['My', 'Name', 'Is', 'Jing.']
 msg = """ Dear,
 How have you been? I am fine .
 There is a container in the fridge that is labeled "Milk Experiment".
 
 Please do not drink it.
 Sincerely, Bob"""
 a4 = msg.split()    
 print(a4)
 """
 ['Dear,', 'How', 'have', 'you', 'been?', 'I', 'am', 'fine', '.', 'There', 'is', 'a', 'container', 'in', 'the', 'fridge', 'that', 'is', 'labeled', '"Milk', 'Experiment".', 'Please', 'do', 'not', 'drink', 'it.', 'Sincerely,', 'Bob']
 """

(5)对齐文本：rjust()、ljust()、center()

通过插入填充字符对齐文本。

rjust()：字符串右对齐，左边补填充字符（默认空格），如果字符串长度大于指定的长度，则不补也不报错
ljust()：字符串左对齐，右边补填充字符
center()：字符串居中，两边补填充字符，先在字符串右边补一个填充字符，再左边再右边，直到长度达到指定长度

 a1 = 'Hello'
 print(a1.rjust(10))
 print(a1.rjust(10, '*'))
 print(a1.rjust(4, '*'))
 print(a1.ljust(10, '*'))
 print(a1.center(10, '*'))
 """
      Hello
 *****Hello
 Hello
 Hello*****
 **Hello***
 """

(6)删除空白字符：strip()、rstrip()、lstrip()

删除字符串左边、右边或两边的空白字符（空格、制表符和换行符）。返回一个新的字符串。

strip()：无参数，则删除开头或末尾的空白字符。
rstrip()：无参数，则删除右边的空白字符
lstrip()：无参数，则删除左边的空白字符
可输入字符串参数，但字符串的顺序并不重要！只要包含这些字符就可以，区分大小写

 a1 = 'Hellol12345oolHe'
 print(a1.strip('eHl'))    # ol12345oo

(7)pyperclip模块：电脑剪贴板

pyperclip是第三方模块，需要先安装包：

 pip install pyperclip

copy()：将内容拷贝至电脑剪贴板。
paste(): 粘贴电脑剪贴板的内容。

 import pyperclip
 a1 = '字符串'
 print(pyperclip.paste())   # 目前剪贴板的内容
 pyperclip.copy(a1)         # 字符串，在别的地方粘贴：字符串

yearx3

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
《Python快速编程上手让繁琐工作自动化》学习总结--第一部分 python编程基础

目录目录前言第1章 python基础1.1 操作符和数据类型1.2 字符串连接(+)和复制(*)1.3 赋值(=)、等于(==)1.4 变量名1.5 内部函数第2章控制流2.1 布尔值(True/False)2.2 比较操作符、布尔操作符2.3 控制流语句2.4 导入模块2.5 sys.exit():提前结束程序第3章函数3.1 def语句和参数3.2 None值（没有值、NoneType数据类型）3.3 局部和全局作用域3.4
复制链接

扫一扫