周二知识点比较零碎，主要包括第三方库的安装，PYC文件，数据类型，列表，字符串，数据运算，字典和set的使用。
pip命令安装第三方库：
Python 导入库的时候，可以用import命令，如果是标准库，那么直接运行即可，如果是第三方的库，需要用pip命令安装之后才能导入。
例如
|
1
|
pip install pandas
|
os.system命令和 os.popen命令：
上一周学习了基本的os.system()命令，这个命令在windows下面同样工作。例如输出IP配置信息
|
1
2
|
>>>
import
os
>>>os.system(
"ipconfig"
)
|
如果希望保存到变量，可以
|
1
2
3
|
>>>
import
os
>>>r
=
os.popen(
"ipconfig"
).read()
>>>
print
(r)
|
Pyc文件：
当在一个Python文件中导入另外一个Python模块的时候，执行会自动生成一个PYC文件。这个文件是一个字节码文件。Python的工作原理是首先把源文件编译成pyc字节码文件，然后这个字节码文件再通过python的虚拟机执行。当手动运行python程序的时候，他不会在硬盘上保存对应的pyc文件，这是因为手动执行的频率一般而言不会太高，当下一次操作的时候，对应的内容可能有更改，因此没有保留的意义。而自动导入执行的时候，会自动创建对应的pyc文件。
数据类型：
int：整型， Python3以后不区分长整型和普通整型了
bool: 布尔型， True或者1为真；False或者0为假
字符串：注意下面例子的区别，他们的结果显示一样，不过+是创建了3个内存分区；而后者只用了1个，效率更高。
|
1
2
3
4
|
>>>name
=
"yuan li"
>>>
print
(
"My name is "
+
name
+
" and You?"
)
>>>
print
(
"My name is %s and You?"
%
name)
My name
is
yuan li
and
You?
|
列表：其他语言里面叫做数组，是使用最最广泛的数据结构
例子：
获取第一个元素
|
1
2
3
|
>>>name
=
[
"zhangsan"
,
"lisi"
,
"wangwu"
]
>>>name[
0
]
'zhangsan'
|
获取最后一个元素
|
1
2
|
>>>name[
-
1
]
'wangwu'
|
获取前第一个元素
|
1
2
|
>>>name[
0
:
1
]
[
'zhangsan'
]
|
获取倒数第2个元素
|
1
2
|
>>>name[
-
2
:
-
1
]
[
'lisi'
]
|
设置步长为2，隔一个取一个元素
|
1
2
|
>>>name[::
2
]
[
'zhangsan'
,
'wangwu'
]
|
切片，获取子列表的第三个元素
|
1
2
3
|
>>>name
=
[
"h"
,
"sjdkf"
,
23
,
232
,[
"22"
,
"33"
,
234
]]
>>>name[
4
][
2
]
234
|
指定索引位置，插入新元素
|
1
2
3
|
>>>name.insert(
3
,
"hhhh"
)
>>>name
[
'h'
,
'sjdkf'
,
23
,
'hhhh'
,
232
, [
'22'
,
'33'
,
234
]]
|
判断是否存在元素
|
1
2
3
4
5
6
7
8
9
10
|
>>>name
[
'jkjjljlj'
,
'sjdkf'
, [
'22'
,
'33'
,
234
],
'end'
]
>>>
22
in
name
False
>>>
'22'
in
name
False
>>>
'end'
in
name
True
>>>
'22'
in
name[
2
]
True
|
指定元素的值来删除 注意一次只能删除一个
|
1
2
3
|
>>> name.remove(
23
)
>>> name
[
'h'
,
'sjdkf'
,
'hhhh'
,
232
, [
'22'
,
'33'
,
234
],
'end'
]
|
一次性删除多个连续的元素，可以使用del
|
1
2
3
|
>>>
del
name[
2
:
4
]
>>> name
[
'h'
,
'sjdkf'
, [
'22'
,
'33'
,
234
],
'end'
]
|
修改某个位置的元素值
|
1
2
3
|
>>> name[
0
]
=
'jkjjljlj'
>>> name
[
'jkjjljlj'
,
'sjdkf'
, [
'22'
,
'33'
,
234
],
'end'
]
|
判断某元素个数
|
1
2
|
>>>name.count(
'22'
)
0
|
把所有的9都改成999
|
1
2
3
4
5
6
7
|
>>> name
=
[
2
,
2
,
3
,
9
,
23
,
9
,
22
,
21
,
9
]
for
i
in
range
(name.count(
9
)):
index
=
name.index(
9
)
name[index]
=
999
print
(name)
[
2
,
2
,
3
,
999
,
23
,
999
,
22
,
21
,
999
]
|
合并name2 到name里面
|
1
2
3
4
|
name.extend(name2)
print
(name)
[
'AA'
,
'jksf'
, [
2
,
99
,
5
],
'234'
,
'klk'
,
'sdf'
]
|
排序 注意混杂字符串和数字的列表在3里面不能排序，但是在2里面会按照ansc编码的值排序
|
1
2
3
4
5
|
>>>
print
(name.sort())
Traceback (most recent call last):
File
"<input>"
, line
1
,
in
<module>
TypeError: unorderable types:
list
() <
str
()
|
根据索引号删除，如果不指定索引号，默认删除最后一位
|
1
2
3
4
|
>>> name.pop(
2
)
print
(name)
[
'AA'
,
'jksf'
, [
2
,
99
,
5
],
'234'
]
|
列表的复制，注意copy只能复制第一层的数据，里面嵌套的列表，仅仅复制了内存地址，换而言之，就是类似一个软连接，在源列表和复制后的列表里，如果修改嵌套的列表内的元素，两个表显示出来的效果都会同时变化。
|
1
2
3
4
5
6
7
8
9
|
>>> name
=
[
'al'
,
'jksf'
,
'sdf'
,[
2
,
3
,
5
],
'234'
]
name3
=
name.copy()
name[
0
]
=
'AA'
name[
3
][
1
]
=
99
print
(name)
print
(name3)
[
'AA'
,
'jksf'
,
'sdf'
, [
2
,
99
,
5
],
'234'
]
[
'al'
,
'jksf'
,
'sdf'
, [
2
,
99
,
5
],
'234'
]
|
如果想进行深度的复制，需要使用copy模块的deepcopy命令, 可以看见deepcopy之后他们是两个独立的个体，互相不受影响
|
1
2
3
4
5
6
7
8
9
|
>>>
import
copy
name
=
[
'al'
,
'jksf'
,
'sdf'
,[
2
,
3
,
5
],
'234'
]
name4
=
copy.deepcopy(name)
name[
3
]
=
'22222'
print
(name)
print
(name4)
[
'al'
,
'jksf'
,
'sdf'
,
'22222'
,
'234'
]
[
'al'
,
'jksf'
,
'sdf'
, [
2
,
3
,
5
],
'234'
]
|
元组：tuple，只有只读属性的列表
用圆括号定义
|
1
2
|
>>> r
=
(
1
,
3
,
4
,
5
)
print
(
type
(r))
|
因为只有只读属性，他的函数只有count和index两个
|
1
2
3
4
|
>>>
print
(
"count of 1:"
,r.count(
1
))
print
(
"index of 3:"
,r.index(
3
))
count of
1
:
1
index of
3
:
1
|
字符串的操作
例如：去掉前后的空格
|
1
2
3
|
>>> user
=
" Yuan Li is a handsome man "
print
(user.strip())
# remove space in the front and end
Yuan Li
is
a handsome man
|
用split分割字符串成为一个列表；用join合并列表成为一个字符串
|
1
2
3
4
5
6
|
>>> names
=
"zhangsan, lisi, wanger"
name2
=
names.split(
","
)
#become list
print
(name2)
print
(
"|"
.join(name2))
[
'zhangsan'
,
' lisi'
,
' wanger'
]
zhangsan| lisi| wanger
|
指定索引输出
|
1
2
|
>>>
print
(names[
0
])
z
|
判断是否包括某个字符
|
1
2
|
>>>
print
(
' '
in
names)
True
|
大写首字母
|
1
2
|
>>>
print
(names.capitalize())
Zhangsan, lisi, wanger
|
两种方式传入参数
|
1
2
3
4
5
6
|
>>> msg
=
"hello,{name}, it's been a long {time}"
msg2
=
msg.
format
(name
=
'Yuan'
,time
=
'period'
)
msg3
=
"hhh{0},dddd{1}"
print
(msg2)
print
(msg3.
format
(
'Yuuu'
,
'222'
))
hello,Yuan, it's been a
long
period
|
切片
|
1
2
3
|
>>> name
=
"abcedefgh"
print
(names[
2
:
5
])
ang
|
输出居中的格式center()
|
1
2
|
>>>
print
(name.center(
40
,
'-'
))
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
abcedefgh
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
|
find查找字符串中包含的字符，如果存在，返回索引，不存在返回-1
|
1
2
3
4
5
|
>>> name
=
"abcedefgh"
print
(name.find(
'e'
))
print
(name.find(
'dddd'
))
3
-
1
|
isdigit()判断输入的是否是数字
|
1
2
3
4
5
6
7
|
>>> age
=
input
(
"your age:"
)
if
age.isdigit():
age
=
int
(age)
else
:
print
(
"invalid data type"
)
your age:>? er
invalid data
type
|
endwith()判断以什么结尾
|
1
2
3
|
>>> name
=
"abcedefgh"
print
(name.endswith(
"fgh"
))
True
|
转换大小写
|
1
2
|
>>>
print
(name.upper())
ABCEDEFGH
|
数据运算
1、算数运算：a=10，b=20
2、比较运算：
3、赋值运算：
4、逻辑运算：
5、成员运算：
6、 二进制运算:
| 运算符 | 描述 | 解释 |
| & | 与运算 | 这个二进制位必须在2组数中都为真，结果才返回真 |
| I | 或运算 | 这个二进制位只需在其中一组数据中为真即返回真 |
| ^ | 异或运算 | 只要这个二进制位在两组数据中不相同就返回 |
| << | 左移运算 | 移动一位相当于乘以2 |
| >> | 右移运算 | 移动一位相当于除以2 |
字典：无序，Key和value配对，key值唯一
例子：定义一个嵌套的字典
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
id_db
=
{
23432424234234324
:{
'name'
:
"alex"
,
'age'
:
23
,
'addr'
:
'Shandong'
},
234324324234324242
:{
'name'
:
'Yuan'
,
'age'
:
24
,
'addr'
:
'Sichuan'
},
234242423222222222
:{
'name'
:
'john'
,
'age'
:
20
,
'addr'
:
'HeNan'
}
}
|
指定Key，输出对应的Value
|
1
2
|
print
(id_db[
234242423222222222
])
{
'name'
:
'john'
,
'age'
:
20
,
'addr'
:
'HeNan'
}
|
更改一个Key的值
|
1
2
3
|
id_db[
234242423222222222
][
'name'
]
=
'hhh'
print
(id_db[
234242423222222222
])
{
'name'
:
'hhh'
,
'age'
:
20
,
'addr'
:
'HeNan'
}
|
添加一个新的key/value 元素
|
1
2
3
|
id_db[
234242423222222222
][
'qq'
]
=
2900032
print
(id_db[
234242423222222222
])
{
'name'
:
'john'
,
'age'
:
20
,
'qq'
:
2900032
,
'addr'
:
'HeNan'
}
|
删除一个元素
|
1
2
|
del
id_db[
234242423222222222
][
'qq'
]
print
(id_db[
234242423222222222
])
|
另外一种删除的方式
|
1
2
|
id_db[
234242423222222222
].pop(
'age'
)
print
(id_db[
234242423222222222
])
|
get，如果该Key存在，返回对应的值
|
1
2
3
|
v
=
id_db.get(
234242423222222222
)
print
(v)
{
'name'
:
'john'
,
'age'
:
20
,
'addr'
:
'HeNan'
}
|
如果不存在，返回None
|
1
2
3
|
v
=
id_db.get(
22222
)
print
(v)
None
|
注意，如果使用直接赋值的方式，如果不存在，它会直接抛出一个错误。
|
1
2
3
4
5
|
v
=
id_db[
22222
]
print
(v)
Traceback (most recent call last):
File
"<input>"
, line
35
,
in
<module>
KeyError:
22222
|
把一个新的字典加入当前的字典
|
1
2
3
4
5
6
|
dic2
=
{
'name'
:
'kkkk'
,
'age'
:
32
,
'addr'
:
'Hongkong'
}
id_db.update(dic2)
print
(id_db)
{
234324324234324242
: {
'name'
:
'Yuan'
,
'age'
:
24
,
'addr'
:
'Sichuan'
},
23432424234234324
: {
'name'
:
'alex'
,
'age'
:
23
,
'addr'
:
'Shandong'
},
'addr'
:
'Hongkong'
,
'name'
:
'kkkk'
,
'age'
:
32
,
234242423222222222
: {
'name'
:
'john'
,
'age'
:
20
,
'addr'
:
'HeNan'
}}
|
直接输出，不建议使用，效率低
|
1
|
print
(id_db.items())
|
分别输出Key和Value
|
1
2
|
print
(id_db.values())
print
(id_db.keys())
|
判断是否存某个Key
|
1
|
print
(
234242423222222222
in
id_db)
|
判断这个key是否存在，如果存在，返回value；如果不存在，创建这个key和对应的value，如果不设置value，那么默认为None
|
1
2
|
print
(id_db.setdefault(
234242423222222222
))
#if exists, erturn the value
print
(id_db.setdefault(
234242423222222122222222
,
'hhhh'
))
#otherwise add a new key/value
|
创建一个新的字典，把列表里面的每一个值拿出来作为key，然后后面的分配同样的值
|
1
2
|
print
(id_db.fromkeys([
1
,
2
,
3
,
3
],
'ddd'
))
{
1
:
'ddd'
,
2
:
'ddd'
,
3
:
'ddd'
}
|
随机的删除一项
|
1
|
print
(id_db.popitem())
|
输出字典的Key和Value，有两种方式，第一种方式适合比较小的字典，效率低；第二种效率比较高
|
1
2
3
4
|
for
k,v
in
id_db.items():
print
(k,v)
for
key
in
id_db:
print
(key,id_db[key])
|
