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