python语言-基础篇

小四
编程
2023-01-23
21热度
0评论

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是一个列表，它的第一个元素就是脚本的文件名； #传递它的启动参数，都会放在列表的后面。我们可以使用这种方式接收用户传递的参数。