第二篇：初识模块、列表、元组、字符串、字典

初次使用sys模块和os模块

试用sys模块：

import sys
#打印路径
print(sys.path)

#打印相对路劲
print(sys.argv)

试用os模块：

import os
# window系统在命令行执行'dir'命令
os.system("dir")
# 功能如上，但用这个可以将运行结果赋予一个变量
# 变量再通过read()打印出来
cmd_res = os.popen("dir").read()
print(cmd_res)

模块的那些事儿

模块是什么？

模块是一个python文件，以 .py 结尾，里面是python代码，能包含数据，对象，以及我们要执行的功能等。我们也可以写模块。

模块怎么使用？

只用找到路径，python使用 import 语句就可以导入了，一般模块的路径会存在 site-packages中，这是我电脑的路径：

C:\Users\Administrator\AppData\Local\Programs\Python\Python35\Lib\site-packages

import语句的使用的三种方式

1 import 模块名 # 导入后可以使用模块的函数

2 from 模块 import * #同上

3 from 模块 import 函数a #导入模块的函数a,为完全导入

.pyc文件是什么

.pyc 是一种二进制文件，是由py文件经过编译后，生成的文件，是一种byte code，py文件变成.pyc 文件后，加载的速度有所提高。

那么为什么说.pyc 文件能让程序的加载速度有所提高呢？
这是因为python程序第一次运行，编译结果保存在 PyCodeObeject （编译器的最终编译结果）中，第一次运行结束后， 解释器将PyCodeObeject 写到.pyc 文件，在下次运行的时候，解释器就直接去.pyc 找到编译结果并执行，如果源代码有变，.pyc 文件也将发生变化。还有一个，需要.pyc 文件是因为.pyc 文件可以对源代码起到保密作用。

python的部分数据类型

python中有6中标准的数据类型：

1. 数字（Number）
2. 字符串（String）
3. 列表（List）
4. 元组（Tuple）
5. 字典（Dictionary）
6. 集合（Sets）

Number

Python3中支持int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。判断是否是数字类型可以使用 isdigit() 函数。

String

#!/usr/bin/env python
# _*_coding_*_

name = "ZERO21 \tand zero21"
print("name", name)
print(name.capitalize())

# lower()只对ASCII的A-Z有效，casefold()对其他语言的小写也有效，例如"ß"
print(name.casefold())
print("ß".casefold())

# 一共30个字符，少于30个用空格填充
print(name.center(30))

# 计算字符'a'的个数
print(name.count("a"))

# 用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False
print(name.endswith("2"))
# 把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8
print(name.expandtabs())

# 检测字符串中是否包含子字符串 str ，
# 如果指定 beg（开始） 和 end（结束） 范围，
# 则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
print(name.find('o'))

# 用于将序列中的元素以指定的字符连接生成一个新的字符串
print('-'.join(name))

# 返回一个原字符串右对齐,并使用空格填充至指定长度的新字符串;
# 如果指定的长度小于原字符串的长度则返回原字符串
# 当然还有左对齐的ljust()函数
print(name.rjust(30))

# 用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
# 第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
# 注：两个字符串的长度必须相同，为一一对应的关系
# maketrans()

# 用来根据指定的分隔符将字符串进行分割
# 如果字符串包含指定的分隔符，
# 则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
# ('ZERO21 ', '\t', 'and zero21')
print(name.partition("\t"))

# 把字符串中的 old（旧字符串） 替换成 new(新字符串)
# 如果指定第三个参数max，则替换不超过 max 次
# 22ERO21   and zero21
print(name.replace('Z', '22'))

# 返回子字符串 str 在字符串中最后出现的位置
# 如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间
# rindex(str, beg=0 end=len(string))
# 12
print(name.rindex('z'))

# 通过指定分隔符对字符串进行切片，如果参数num 有指定值，
# 则仅分隔 num 个子字符串
# ['ZERO21 ', 'and zero21']
print(name.rsplit('\t'))

# 删除 string 字符串末尾的指定字符（默认为空格）
print(name.rstrip())

# 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写
# Zero21    And Zero21
print(name.title())

# 根据参数table给出的表(包含 256 个字符)转换字符串的字符,
# 要过滤掉的字符放到 del 参数中
# name.translate()

# 将字符串中的小写字母转为大写字母
# ZERO21    AND ZERO21
print(name.upper())

# 返回指定长度的字符串，原字符串右对齐，前面填充0
# 000000000000ZERO21    and zero21
print(name.zfill(30))

List

#!/urs/bin/env python
# _*_coding:UTF-8_*_

# 空列表
student = []
student = ['Tom', 'Juny', 'Bob','Zero21','Kim']
# 取列表值，索引从0开始
# 取Tom
print(student[0])

# 切片的方式
# 固首不固尾。切片中1是有取到的，到时后面的3是没有取到
print(student[1:3])

# 增
# 1.增加的值放在最后
# ['Tom', 'Juny', 'Bob', 'Zero21', 'Kim', 'Adder1']
student.append('Adder1')
print(student)

# 2.第一个参数为索引值
# ['Tom', 'Lucy', 'Juny', 'Bob', 'Zero21', 'Kim', 'Adder1']
student.insert(1, 'Lucy')
print(student)

# 改
# ['Tom', 'Lucy', 'Ivy', 'Bob', 'Zero21', 'Kim', 'Adder1']
student[2] = 'Ivy'
print(student)

# 删
# 1.remove()
# ['Tom', 'Lucy', 'Bob', 'Zero21', 'Kim', 'Adder1']
student.remove('Ivy')
print(student)

# 2.del
# ['Tom', 'Lucy', 'Bob', 'Zero21', 'Kim']
del  student[5]
print(student)

# 3.pop()——输入参数作用相当于del, 没输入删除最后一个
# ['Tom', 'Lucy', 'Zero21', 'Kim']
student.pop(2)
print(student)

# 找
# index()函数,找到返回索引值，找不到报错
# 3
print(student.index('Kim'))

# 统计
# 1
print(student.count('Zero21'))

# 并
# ['Tom', 'Lucy', 'Zero21', 'Kim', 'stu2_1', 'stu2-2']
student2 = ['stu2_1', 'stu2-2']
student.extend(student2)
print(student)

列表的copy是浅copy,对于嵌套在列表里面的列表，只是简单的复制，但两个变量的值的变化是联系在一起的，还不是独立的两个变量。

name1 = ['a','b','c','d','e','f',['h','i']]
name2 = name1
print(name1)
print(name2)

name2[6][0] = 'k'
print(name1)
print(name2)

'''
['a', 'b', 'c', 'd', 'e', 'f', ['h', 'i']]
['a', 'b', 'c', 'd', 'e', 'f', ['h', 'i']]
['a', 'b', 'c', 'd', 'e', 'f', ['k', 'i']]
['a', 'b', 'c', 'd', 'e', 'f', ['k', 'i']]
'''

浅复制有三种方式：

import copy
person = ['ZhangSan', 'LiShi', 'WangWu', ['man', '18']]
# 第一种方式
p1 = copy.copy(person)
print('这是p1：', p1)
# 第二种方式
p2 = person[:]
print('这是p2：', p2)
# 第三种方式
p3 = list(person)
print('这是p3：', p3)
#我们更改其中一个试一试
p1[3][0] ='Woman'
# 真的都变成女的了
print('这是p1：', p1)
print('这是p2：', p2)
print('这是p3：', p3)

'''这是运行结果：
这是p1： ['ZhangSan', 'LiShi', 'WangWu', ['man', '18']]
这是p2： ['ZhangSan', 'LiShi', 'WangWu', ['man', '18']]
这是p3： ['ZhangSan', 'LiShi', 'WangWu', ['man', '18']]
这是p1： ['ZhangSan', 'LiShi', 'WangWu', ['Woman', '18']]
这是p2： ['ZhangSan', 'LiShi', 'WangWu', ['Woman', '18']]
这是p3： ['ZhangSan', 'LiShi', 'WangWu', ['Woman', '18']]
'''

那么这些都是浅复制，如果我要真正的复制，那该怎么办呢？嗯，这个时候就可以用上”深复制“的 deepcopy() 函数了。

import copy
person = ['ZhangSan', 'LiShi', 'WangWu', ['man', '18']]
p1 = copy.deepcopy(person)
print('这是p1：', p1)
p1[3][0] ='Woman'
# 真的都变成女的了
print('这是person：', person)
print('这是更改后的p1：', p1)

'''
这是p1： ['ZhangSan', 'LiShi', 'WangWu', ['man', '18']]
这是person： ['ZhangSan', 'LiShi', 'WangWu', ['man', '18']]
这是更改后的p1： ['ZhangSan', 'LiShi', 'WangWu', ['Woman', '18']]
'''

Tuple

元组，只能查，不能改。Python 的元组与列表类似，不同之处在于元组的元素不能修改，所以又叫只读列表。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

#!/usr/bin/env python
# _coding:UTF-8_*_
# 创建一个空元组
t = ()
t = ('ZERO21', 'Man', '20')

# 访问元组
print(t[1])
# count()
print(t.count('20'))

# index()
print(t.index('ZERO21'))

# 元组不能修改，以下语句有错
# t[1] = 'Woman'

# 删除整个元组
del t

Dictionary

字典，有两个特性，一是无序，二是key必须是唯一的。

#!/usr/bin/env python
# _*_coding:UTF-8_*_
dictTest = {'name':'ZERO21', 'age': '20', 'sex': 'Man'}

# 添加
# {'phoneNum': '159******88', 'name': 'ZERO21', 'sex': 'Man', 'age': '20'}
dictTest['phoneNum'] = '159******88'
print(dictTest)
# 改
# {'age': 18, 'name': 'ZERO21', 'sex': 'Man'}
dictTest['age'] = 18
print(dictTest)

# 如果keyz值没有，会自动添加一个
# {'age': 18, 'sex': 'Man', 'name': 'ZERO21', 'address': 'Zhuhai'}
dictTest['address'] = 'Zhuhai'
print(dictTest)

# 查
# 1.在十分确定有该key的值时使用，才能不报错
# KeyError: 'phoneNum'
# print(dictTest['phoneNum'])
# 2.建议使用这个，如果没有该key的值，会返回none
# None
print(dictTest.get('phoneNum'))

# 删
# 1.del
del dictTest['address']

# 2.pop() 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
# ZERO21
print(dictTest.pop('name'))

# 3.popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)
# ('age', 18)
print(dictTest.popitem())

字典的遍历：

# 1.这种它有转换过程，没那么高效
for key,value in dictTest.items():
    print('key:', key, 'value:', value)

# 2.建议这种,相对高效一点
for i in dictTest:
    print(i,dictTest[i])

Sets

集合是一种无序不重复集，它可以用set函数创建集合，也可以用大括号{}创建，但不能直接a = {} 来创建一个空集合，这样创建的是空字典。基本功能是关系测试和消除重复元素。它可以做一些并集、交集、差集等数学逻辑运算。
假设有a,b两个集合：

写法	说明
a | b	并集
a & b	交集
a - b	差集
a ^ b	对称差集

集合的操作：

操作	代码	说明
增	setTest.add()	增加元素
	setTest.update([‘aa’,’bb’,’cc’])	增加多个元素
删	setTest.remove(‘aa’)	删除某个元素
	setTest.clear()	删除所有元素
	setTest.pop()	删除某个元素，但不确定哪个
复制	setTest.copy()

还有一些操作，先假设有两个集合s1,s2：

操作	说明
s1.update(s2)	s2的元素增加到s1
s1 |= s2
s1.intersection_update(s2)	s1的值变成s2与s1交集
s1 &= s2
s1.difference_update(s2)	在s1中删除了s2中含有的元素后，返回一个新s1
s1 -= s2
s1.symmetric_difference_update(s2)	返回含有s1或者s2中有而不是两者都有的元素的s1
s1 ^= s2