python语言-基础篇

python语言是软件自动化测试工程师必学必用的编程语言,而且极易上手。本文是学习拉勾自动化测试训练营的pyhton基础的笔记,适合零基础的同学阅读,大神请绕路哈哈。下一篇将会记录pyhton语言进阶部分知识。

一.关于Pyhton语言的理解

Python 是一种面向对象、解释型、弱类型的脚本语言,也是一种功能强大而完善的通用型语言。

1.1.python的优点:

简单易学,功能强大:python可以用于AI、云计算、数据分析、网站开发等诸多领域,且具有很多科学库避免重复造轮子;

跨平台性:由于解释型,使得python天然具有跨平台性,只要平台提供了 Python 解释器,Python 就可以在该平台上运行;

1.2.python的缺点:

由于是解释型语言而存在一些劣势:

运行速度较慢:Python 程序的运行效率比 C++、Java 等都要慢得多。源代码加密困难:不像编译型语言的源程序会被编译成目标程序,Python 直接运行源程序,因此对源代码加密比较困难。

1.3.pyhton解释器

由于python是一门解释性语言,需使用专门的解释器对py源代码逐行解释成二进制码;

常见的python解释器有CPython、IPyhton、PyPy、Jython;

CPython是C语言开发的、使用最多的python解释器;IPyhton是基于CPython之上的交互型解释器,非常方便用于数据科学领域;PyPy 是用 Python 实现的 Python 解释器,采用JIT技术,比标准的CPython要快很多;Jython本质是一种完整的语言,而不是一个Java翻译器或仅仅是一个Python解释器,它是一个Python语言在Java中的完全实现。Jython也有很多从CPython中继承的模块库

二.python的核心基础语法

2.1.变量

1.变量的定义与赋值

python是弱类型语言,所以定义变量无需声明变量类型,直接赋值;举个例子:

a=hello world #定义一个变量a print(a) #打印 hello world a, b = 1, 2 #定义2个变量名a,b,并赋值为1,2 a = b = c = 1 #定义3个变量且赋值都为1 #变量定义完成后,我们可以随意读取、修改它的值; #比如前面定义并赋值变量a为hello world,可以直接赋值覆盖原理的值; a=I Like Python

PS:变量的销毁

一般情况下python的垃圾回收机制会帮我们销毁变量,若想手动销毁,则用: del 变量名

2.变量的名规则

python变量名遵循以下的规则: 变量名由字母、数字和下划线组成,也就是a-z, A-Z, 0-9和_; 变量名不能以数字开头; 变量名是区分大小写的,比如a 和 A就是两个不同的变量;

约定俗称的命名规范:

用见名知意的英文单词命名(且最好不加数字);不能与python关键字重名;常用两种风格的变量名:①单词之间用下划线隔开;②每个单词的首字母使用大写字母(称驼峰命名法 )

2.2.数据类型与类型转换

2.2.1数据类型

pyhton是弱类型语言,变量不区分类型,但是python的值有类型;

python的数值有3种基本数据类型:

数值(包括整数浮点数):包括 整形(int)和浮点型(float)

字符串:用双引号 或 单引号括起来,若想在字符串识别引号,在引号前加\

布尔值(bool): True,False [注意首字母大写]

此外,python还有个特殊值,None;常用来 赋一个还没想好的初值;

2.2.3.类型转换

2.3运算符

2.3.1算术运算符与赋值运算符

算术运算符:

加/减/乘/除:+,-,*,/ 取模:% 指数:** 取整除:// 小括号:()

赋值运算符:(算数运算符的基础上,加个=)

如:加/减/乘/除/取整除法赋值运算符:+=、-=、*=、/=、//=

2.3.2逻辑运算符与比较运算符

逻辑运算符

与:and 或:or 取反(非):not

比较运算符

等于:== 不等于: != 大于:> 小于:< 大于等于:>= 小于等于:≤

2.4流程控制

这部分过于基础,直接上个简单的demo;

2.4.1.条件控制

1.if...else...语句

#判断奇偶数 num = 5 # 通过取模运算判断num是否能被2整除 if num % 2 == 0: print(str(num) + "是一个偶数") else: print(str(num) + "是一个奇数")

2.elif语句

#elif只能用在if判断之后,else之前; #判断分数等级:0分以下的为不及格,60~90分为合格,90分以上为优秀 score = 89 if score < 60: print("您的考试成绩不及格") elif score < 90: print("您的考试成绩合格") else: print("您的考试成绩优秀")

3.if条件嵌套

#比上个例子更细判断分数等级:60~70分为合格,70~90分为良好,90分以上为优秀; score = 88 if score >= 60: if score < 70: print("您的考试成绩为合格") elif score < 90: print("您的考试成绩为良好") else: print("您的考试成绩为优秀") else: print("您的考试成绩不及格")

4.自动类型转换

if 和 elif 的后面总跟着一个表达式,这个表达式的结果必须是True或者False,如果表达式运算出来的 结果不是一个布尔值,则会自动将结果转换为布尔值,无论它是什么类型的值;

count = 1 if count: print("条件成立") else: print("条件不成立") #打印条件成立

2.4.2.循环语句

1.while循环

# while 表达式: # 表达式为真则执行的语句,知道表达式不成立; #循环打印建国喝了1-10杯酒; glass = 0 while lap < 10: lap += 1 print("建国喝完了第" + str(lap + 1) + "杯酒")

2.for循环

for循环可以用来遍历序列; (序列:一个可迭代的有序的集合)

#比如遍历字符串; seq = "你好" for s in seq: print(s) #打印结果: #你 #好 #for循环来打印一连串的数字 for i in range(5): print(i) #打印了0,1,2,3,4这5个数;0开始算起,不包括最后1位; #range函数的作用就是提供一个从0到4的迭代器,而for可以遍历这个迭代器; #for循环嵌套 #打印九九乘法表 for i in range(1, 10): for j in range(1, i + 1): print("%s*%s=%s" % (j, i, i * j), end=" ") print()

3.关键字break和continue

#break跳出整个循环,结束循环; #举个例子--打印小数的整数部分; s = "314.9237834829" for i in s: if i == .: print() break print(i, end=) #314 #continue跳出当前循环,继续下一次循环; #举个例子--打印出10以内所有偶数相加的式子 total = 0 for i in range(11): if i % 2 == 1: continue print(i, end=" + ") total += i print(" = %s" % total) #2+4+6+8+10=30

三.python数据结构

3.1.字符串

3.1.1、 %格式化占位符

#整数占位符:%d #如果给%d 传入一个浮点数,那它会自动将它转换成整数 print("%d" % 3.99) # 输出3 #浮点数占位符:%f print("%f" % 3.14) #3.140000 #指定精度的浮点数占位符:%.f print("%.2f" % 3.1415926) #3.14 #字符串占位符:%s #%s 是胜任最广泛的占位符,它可以对应任何类型的变量 print("%s" % 100) # 输出100 print("%s" % 3.14) # 输出3.14 print("%s" % "python") # 输出python #输出百分号%:%% report = "%d%s公司营收增长了%.2f%%;" % (2021, "腾讯", 20.28) print(report) #2021年腾讯公司营收增长了20.28%;

3.1.2、format函数

#format函数可以像%那样来格式化多个参数 #{0}表示第一个参数,{1}{2}表示第二、第三个参数。如果有参数在字符串出现多次,可以不用重复的传入。 {0}的GDP为{1:,}...虽然它的GDP只有{1:,}美元,但它的人均GDP高达18万美元.format("摩纳哥", 7100000000)

3.1.3、字符串索引和切片

#索引--字符串的索引,正向数从0开始,逆向数从-1开始; "CHINA"[1] # 第2个字符"H" "CHINA"[-1] # 最后一个字符"A" "CHINA"[-2] # 倒数第二个字符"N" ​ #切片 "CHINA"[0:6] # CHINA "CHINA"[0:] # CHINA #前面的0也可以不写,冒号左边为空表示从第一个字符开始截取。 "CHINA"[:] # CHINA ​ "CHINA"[:3] # 从0到第3个: CHI "CHINA"[2:] # 从第3个到末尾: INA ​ # 每隔两个字符截取一个 "CHINA"[::2] # CIA 第二个冒号表示截取步长,这里的2表示每两个字符取一个,如果不传,默认就是每一个都取。步长也 可以为负数,如果传递了一个负数,则表示是从右往左进行截取; # 从右往左每隔两个两个字符截取一个 "CHINA"[::-2] # AIC 倒序输出一个字符串,可以这样写: "CHINA"[::-1] # ANIHC

3.1.4、字符串函数

1.去除空白字符 #strip函数的作用就是去除字符串首尾的所有空白字符。不会去除掉字符串之间的空白字符 " a b c ".strip() #结果a b c #lstrip 和 rstrip 函数,分别去除字符串左边和右边的空白字符 " abc ".lstrip() # 结果abc " abc ".rstrip() # 结果 abc ​ 2.大小写 # 将所有字符变成大写 "china".upper() # CHINA # 将字符串的首字母变成大写 "china".capitalize() # China # 将所有字符变成小写 "CHINA".lower() # china # 将每个单词的首字母变成大写 "i have a dream".title() # I Have A Dream ​ 3.判断字符串是否以指定的字符串开头或者结尾 startswith #是否以指定的字符串开头 endswith #是否以指定的字符串结尾 isdigit #是否是一串数字 islower #是否全是小写字母 isupper #是否全是大写字母 ​ 4.字符串长度 len len("China") # 5 #len() 也可以测量其他所有有长度的对象 r = range(10) len(r) # 10 ​ 5.查找函数:find、index--find若找到返回第一个字母索引,没找到返回-1;index若梅找到会报错; s.find("not_exists") # 结果是-1 ​ 6.计数count "abba".count(a) # 2 ​ 7.替换函数replace "abba".replace(a, b) # 结果是bbbb apple banana.replace(apple, orange) # 结果是orange banana

3.2.元组

字符串是一种序列,它可以迭代循环、按索引访问、切片访问;

但它的组成只能是单个的字符,于是有了更多元化的序列:元组;

元组和字符串都是只读的,也就是不可修改的 ;

3.2.1.关于元组的定义、访问、转换:

#元组的定义--小括号() t = (My, age, is, 18) #索引访问元组元素时用中括号[] t[0] # my t[-1] # 18 #切片访问,返回的是一个包含切片片段的新元组 t[0:2] # (My, age) #元组定义的时候也可以不用括号 t = My, age, is, 18 #元组中只有一个元素的时候,必须要加一个逗号 t = (solo, # 或者不带括号 t = solo, #强制转换为元组 tuple(abc) # (a, b, c) tuple(range(5)) # (0, 1, 2, 3, 4)

3.2.2、元组操作

1、用join把元组序列拼接成一个整体的字符串 # 注意最后一个元素-- 18 是字符串,join函数要求参数序列中的每一个元素都必须是字符串 t = (My, age, is, "18") print(" ".join(t)) # 输出结果:My age is 18 ​ 2、count、index、len函数 t = (a, b, b, a) t.count(a) # 2 t.index(b) # 1 len(t) # 4 ​ 3、in 判断元组中是否包含某个元素 a in t # True x in t # False ​ 4、遍历元组 #元组属于序列,所以可以像字符串那样去遍历它; tup = (a, b, c, d, e) for i in tup: print(i)

3.3.列表

列表可以理解为可变的元组;

使用方式跟元组差不多,区别就是列表可以动态的增加、修改、删除元素;

3.3.1.定义列表

# 定义一个空列表 lst = [] lst = list() # 定义带有初始值的列表 lst = [1, 2, 3] lst = ["a", 1, 2, 3, "b", "c"] lst = list(range(5)) lst = list("abc") lst = list((1, 2, 3))

3.3.2.列表的增删改查

#列表的访问和字符串、元组一样,索引或者切片都可; lst = [a, b, c, d, e] #访问 lst[0] # a lst[-2] #d lst[1:3] # [b, c] #添加元素 lst.append(x) #lst=[a, b, c, d, e, x] #修改列表中的元素 lst[-1] = f # 修改后列表变为: [a, b, c, d, e, f] #删除列表中的元素 del lst[1] # 删除后列表变为:[a, c, d, e, f]

3.3.3.列表函数

#1.insert() #append是在最后添加,insert则可以向任意位置添加。 lst = [a, c, e] # 在第二个元素c前面插入一个字符串b lst.insert(1, b) # lst现在的值是[a, b, c, e] # 在最后一个元素e前面插入一个字符串d lst.insert(-1, d) # lst现在的值是[a, b, c, d, e] #2.pop()--弹出最后一个元素 #每次调用pop函数会从列表中“弹”出最后一个元素; lst=[a, b, c, d, e] temp = lst.pop() print(lst) # [a, b, c, d] print(temp) # e #带参数的pop,可以弹出指定位置的元素 lst=[a, b, c, d] temp = lst.pop(2) print(lst) # [a, b, d] print(temp) # c #3.remove()---删除指定内容的元素 lst = [1, 2, 1, a, b, c] lst.remove(a) print(lst) # lst的值为[1, 2, 1, b, c] #4.del()--删除指定下标索引的元素 lst = [11,22,33,44] del lst[2] #[11, 22, 44] #5.clear--清空列表所有元素 lst = [1,2,3,4] lst.clear() print(lst) # 结果为[] #6.extend()--添加1或多个元素 #append函数每次只能添加一个元素,而extend可以添加一组 lst = [] lst.extend(range(5)) print(lst) # [0, 1, 2, 3, 4] lst.extend([5, 6, 7]) print(lst) # [0, 1, 2, 3, 4, 5, 6, 7] #7.reverse()--将整个列表反转 lst=[0, 1, 2, 3, 4, 5, 6, 7] lst.reverse()# [7, 6, 5, 4, 3, 2, 1, 0] #8.reverse()--将列表中的元素排序,默认升序; #将列表中的元素重新排序,对于数值,默认按从小到大的顺序排列; lst = [3, 5, 2, 1, 4] lst.sort() # [1, 2, 3, 4, 5] #想要让列表从大到小排列,可以加reverse参数; lst = [3, 5, 2, 1, 4] lst.sort(reverse=True) # [5, 4, 3, 2, 1] #对于字符串,则会按照它们的ASCII值的顺序排列; ord(A) # 65 chr(66) # B #sort函数会比对每个字符串的第一个字符,如果第一个字符相同,则比对第二个字符,以此类推 fruits = [apple, banana, orange, blueberry] fruits.sort() # [apple, banana, blueberry, orange] #9.copy()--复制一份新列表; lst1 = [1, 2, 3] lst2 = lst1.copy() lst1.append(4) print(lst1) # [1, 2, 3, 4] print(lst2) # [1, 2, 3]

3.3.4.列表表达式

#可以快捷的创建列表的表达式; #1.普通方法创建20内偶数值的列表 even_nums = [] for i in range(0, 20, 2): even_nums.append(i) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] ​ #2.使用列表表达式,一句顶前面3句 #列表表达式方法一: [i * 2 for i in range(10)] # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] #列表表达式方法二: [i for i in range(0, 20, 2)] ​ #用列表表达式生成大写的26个字母 [chr(i) for i in range(65, 65 + 26)]

3.3.5.列表模拟栈

#pyhton没有java等其他语言数组、栈的概念;我们通常实现用列表来模拟java语言中数组、栈实现相应功能; #1.数组,其实pyhton中列表就相当于别的语言的数组 arrays=[1,2,3,4,5,6] #定义列表并初始化,相当于定义数组并初始化; print(arrays[1])#输出元素2,相当于访问数组第一个元素; ​ #2.模拟栈 stack=[]#相当于初始化一个空栈 stack.append(1)#相当于入栈 stack.append(2) stack.append(3) e_top=stack.pop()#删除栈顶元素并返回; e_top=stack[-1]#访问栈顶元素

3.4.字典

3.4.1.字典的定义与

1,可以直接用花括号{}定义字典 ;

#每一行冒号左边的是键(key),右边的是值(value),称作键值对,以逗号分隔开 sales = {Peter: 213,John: 253} #两个一组、一一对应的列表可以直接转换为字典 sale=[(Peter, 213), (John, 253)] sales = dict(sale) # sales现在的值变成了:{Peter: 213,John: 253} #增加 sales[mike] = 300 #{Peter: 213, John: 253, mike: 300} #修改 sales[mike] = 200 #{Peter: 213, John: 253, mike: 200} del sales[Peter]#{John: 253, mike: 200}

3.4.2.字典的遍历

#遍历字典 #items函数将字典内的内容转换成了一种可迭代的序列,以供for循环遍历,遍历出来的每一项是一个元组,包含#了键和值 for key, value in sales.items(): print(key, value) #遍历字典所有的key,不用items函数; for key in sales: print(key)

3.4.3.字典函数

#如果直接访问字典中一个不存在的key,会产生报错,所以通常如果不确定是否存在某个key时,会先判断一下: if mike in sales: print(sales[mike]) else: print(mike, 0) #get函数可以替代上面4行代码功能; #在字典中查询mike键所对应的值,如果不存在mike键,则返回0 sales.get(mike, 0) ​ #keys/values取字典的键/值;返回一个列表; sales={Peter: 213, John: 253, mike: 200} sales.keys() #dict_keys([Peter, John, mike]) sales.values() #dict_values([213, 253, 200]) ​

3.5.集合

集合:无序的、不重复的序列 ,一般常用来删除重复数据,还可以计算交集、并集等;

3.5.1.集合的定义

#2种方法--使用{}或set() nums = {1, 2, 3, 4, 5} nums = set([1, 2, 3, 4, 5]) ​ #常用:去除列表或元组的重复元素 lst = [1, 2, 1, 3, 4, 5] list(set(lst)) #[1, 2, 3, 4, 5]

3.5.2.集合的操作

#1.遍历集合 nums={1,2,3,4} for n in nums: print(n) 2.增加一个元素 nums.add(5) #nums={1,2,3,4,5} #3.改--集合元素不能修改! #已经加入集合的元素不能修改,只能删除; #4.删除元素--remove,discard,pop #remove()---删除集合指定的元素,若元素不存在会报错: nums.remove(5)#nums={1,2,3,4} #若想删除不存在的元素不报错,用discard() nums.discard(5)#删除前nums={1,2,3,4}不存在元素5,但不会报错; #pop()---从集合内删除并返回第一个元素: num = nums.pop()#1

3.5.3集合函数

# 定义两个集合 s1 = {1, 2, 3} s2 = {3, 4, 5} # 求交集 s1.intersection(s2) # {3} # 求并集 s3 = s1.union(s2) print(s3) # {1, 2, 3, 4, 5} # 是否是子集 s1.issubset(s3) # True # 是否是父集 s3.issuperset(s2) # True

四.函数与对象入门

没错,这部分是关于函数与面向对象的基础入门部分,下一篇会记录进阶部分的内容。

4.1.函数

4.1.1.函数的定义与调用

用def关键字来定义函数;

def hello(name): print("Hello", name) hello("Python") #Hello Python

4.1.2.函数的参数

函数的参数可以有一个,也可以有多个,也可以没有参数;

#定义1个含有2个参数的函数; def hello(name, sex): if sex == 男: print("Hello, Mr", name) elif sex == 女: print("Hello, Miss", name) hello("Zhang", "男")#Hello, Mr Zhang hello("Wang", "女") #Hello, Miss Wang ​ #函数可以有1个或多个/全部参数带默认值; #定义1个全部参数待遇默认值的函数; def hello(name=Anonym, sex=女): if sex == 男: print("Hello, Mr", name) elif sex == 女: print("Hello, Miss", name) hello() # Hello, Miss Anonym

4.1.3.匿名函数

若临时需要简单功能的函数,就可以定义匿名函数,随用随丢;

#匿名函数的定义-> 用lambda关键字:隔开 revenue= [(1月, 5610000), (2月, 4850000), (3月, 6220000)] revenue.sort(reverse=True, key=lambda x:x[1]) print(revenue) #[(3月, 6220000), (1月, 5610000), (2月, 4850000)] #列表的sort函数key参数,它只能接收一个函数类型的值; key = lambda x: x[1] #匿名函数

4.2.面向对象

用关键字class定义类;类名一般使用名词,且使用驼峰式命名法。

#定义一个Dog类 class Dog: #self代表的是实例自身,意思是“我的” def __init__(self, size, color, breed=土狗): #__init__是构造函数 self.breed = breed #类属性 self.color = color self.size = size def eat(self): #类方法 print("I like bones") def run(self): print("Ill catch you.") def bark(self): print(我是一只%s%s色的%s % (self.size, self.color, self.breed)) #创建Dog的实例 dog = Dog("小", "棕", "泰迪犬") dog.bark() #我是一只小型棕色的泰迪犬 #用isinstance判断对象与类的关系 isinstance(dog, Dog) # True

五.模块与包管理

5.1模块的导入与自定义模块

Python中具有丰富的标准库和第三方库,除pyhton内置库,其他库在使用前先要导入;

自己定义模块,是我们在项目中组织代码的基本方式 ;

#导入模块 import 模块名 #举例子: import math #导入1个math模块; import sys, os #导入2个模块,模块间用逗号隔开; #导入子模块或函数 from 模块名 import 子模块或函数 #举例子: from math import sqrt from math import sqrt, pow #自定义模块目录结构如下: ├── project #项目名 ├── main.py #项目的入口文件,实际运行的时候就是从它启动 └── shopcart #自定义包 ├── __init__.py # 包中自带 __init__.py 文件 ├── Cart.py └── Goods.py #引用方法 from shopcart.cart import Cart from shopcart.goods import Goods

5.2常用内置模块

5.2.1.datetime类 - 日期时间类型

from datetime import datetime, timedelta # 返回当前时间的datetime对象 now = datetime.now() type(now) # 查看当前时间的年、月、日 print(now.year, now.month, now.day) # 查看当前时间的时间戳,精确到微秒 now.timestamp() # 返回指定格式的日期字符串, 下面的返回 2021-11-10 00:15:51 datetime.now().strftime(%Y-%m-%d %H:%M:%S) # 将指定格式的字符串转换为日期时间对象 datetime.strptime(2021-11-11 00:00:00, %Y-%m-%d %H:%M:%S) #得到datetime对象后,可以对它进行修改 now = datetime.now() last_year = now.replace(year=2020) print(last_year.strftime(%Y-%m-%d %H:%M:%S)) #显示去年的今天现在这个时候的时间 #求两个datetime对象之间相差的时间 delta = now - last_year type(delta)

5.2.2.time - 时间的访问和转换

import time # 返回当前时间戳 time.time() # 返回当前时间的格式化字符串 time.strftime(%Y-%m-%d %H:%M:%S) ​ print("好累呀,我要小睡3秒钟") time.sleep(3) #睡眠3秒 print("好啦,我又元气满满!")

5.2.3.random - 生成随机数

random根据当前的系统时间作为随机数种子,所以可以保证生成的随机数不会重复;

# 生成一个随机浮点数,范围[0.0, 1.0) random.random() # 生成1到100之间的随机整数,包括1和100 random.randint(1, 100) # 从序列中随机抽出一个元素 random.choice([a, b, c, d, e, f, g]) # 从序列中随机抽出k个元素,注意抽出来的元素可能会重复 random.choices([a, b, c, d, e, f, g], k=2) # 跟choices函数类似,但它是不重复的随机抽样 random.sample([a, b, c, d, e, f, g]) # 将一个序列随机打乱,注意这个序列不能是只读的 lst = [a, b, c, d, e, f, g] random.shuffle(lst)

5.2.4.os - 操作系统接口

os模块提供了一种使用与操作系统相关的功能的便捷式途径;

# 获取当前目录的路径 os.getcwd() # 创建指定目录 os.mkdir(path) # 与 mkdir() 类似,但会自动创建到达最后一级目录所需要的中间目录。 os.makedirs(path) # 返回一个列表,该列表包含了 path 中所有文件与目录的名称。 os.listdir() ​ # 显示当前目录的绝对路径 os.path.abspath(./) os.path.abspath("__file__") ​ 如果 path 是 现有的 目录,则返回 True。 os.path.isdir(path) # 如果 path 是 现有的 常规文件,则返回 True。 os.path.isfile() # 目录分隔符 os.sep # 合理地拼接一个或多个路径部分。 os.path.join(path, *paths) # 返回路径 path 的目录名称 os.path.dirname("/tmp/test.txt") # /tmp # 返回路径 path 的基本名称,文件名或是最后一级的目录名 os.path.basename("/tmp/test.txt") # test.txt os.path.basename("/tmp/test") # test

5.2.5.sys - 系统相关参数及函数

sys.path #返回结果如下--列表 [, #这里第一个是空字符串,它表示当前目录;用import语句可以导入模块,靠的就是它。 /Users/envs/py3/bin, /Users/envs/py3/lib/python36.zip, /Users/envs/py3/lib/python3.6, /Users/envs/py3/lib/python3.6/lib-dynload, /Users/envs/py3/lib/python3.6/site-packages, /Users/envs/py3/lib/python3.6/site-packages/pyspider-0.3.10-py3.6.egg, /Users/envs/py3/lib/python3.6/site-packages/setuptools-27.2.0-py3.6.egg, /Users/envs/py3/lib/python3.6/site-packages/IPython/extensions, /Users/.ipython] ​ sys.argv #表示启动的时候传递给Python脚本的命令行参数; type(sys.argv) #<class list> #sys.argv是一个列表,它的第一个元素就是脚本的文件名; #传递它的启动参数,都会放在列表的后面。我们可以使用这种方式接收用户传递的参数。