【Python之路】—— 基础部分

时间：2019-08-25 15:40:16 阅读：92 评论：0 收藏：0 [点我收藏+]

标签：列表 html iterable 测试 map isp super python解释器保存

输入和输出

a = input()：用户从电脑输入一些字符，放到a中
a是一个变量，随便起什么名字都可以

print():
在括号中加上字符串，就可以向屏幕上输出指定的文字
print("这里写字符串")

接受多个字符串，用逗号“,”隔开，就可以连成一串输出
print("this","is","python")

缩进

tab : 4个空格

数据类型和变量

整数：任意大小的整数。无大小限制，整数运算永远是精确。

浮点数：小数。写法：数学写法，如1.23，3.14；科学计数法：1.23x10^9在程序中写成1.23e9，浮点数运算则可能会有四舍五入的误差

字符串：以单引号‘或双引号"括起来的任意文本。

布尔值：True,False。首字母大写。运算：and、or、not

空值：None

变量: 程序中就是用一个变量名，变量名必须是大小写英文、数字和_的组合，且不能用数字开头。

常量：全部大写的变量名表示常量，如PI=3.14159265359

注意：

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：

a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下（// 表示注释）：

int a = 123; // a是整数类型变量
a = "ABC"; // 错误：不能把字符串赋给整型变量

总结：

/：

10 / 3  # 3.3333333333333335

/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

//:称为地板除,整数的地板除//永远是整数，即使除不尽。

10 // 3 # 3

余数运算%，可以得到两个整数相除的余数：

10 % 3 # 1

编码

历史简介

ASCII编码：由于计算机是美国人发明的，因此，最早只有127个字母被编码到计算机里，也就是大小写英文字母、数字和一些符号，比如大写字母A的编码是65，小写字母z的编码是122。

Unicode编码：Unicode把所有语言都统一到一套编码里，解决各国编码方式不一样造成的乱码问题。但是存储空间大大；

UTF-8编码：一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。

节省空间。

ASCII编码实际上可以被看成是UTF-8编码的一部分

写文件的编码转换过程

内存中使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

用记事本编辑的时候，

读：UTF-8==>Unicode。硬盘到内存

保存：Unicode==>UTF-8。内存到硬盘

技术图片

字符串

Python 3的字符串使用Unicode，直接支持多语言。

特性：不可修改

格式化

%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

%s把任何数据类型转换为字符串

字符串格式化符：.format

print("{} is eating {}.".format('benjie','meat'))
print("{a} is eating {b}.".format(a = 'benjie',b = 'meat'))
print('{0} is eating {1}.'.format('benjie','meat'))

str到byte的转换

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes

bytes类型：带b前缀的单引号或双引号表示：

x = b'ABC'

"字符串".encode()：字符串到bytes

b"字节".decode()：bytes到字符串

1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

列表、集合、字典

列表（list）

特性：有序

访问列表中元素：list[index],索引是从0开始的：

names = ['benjie','jack','alex']
print(names[0])  # benjie
print(names[1])  # jack
print(names[2])  # alex
# print(names[3])# IndexError: list index out of range

切片

>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
>>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
['Tenglan', 'Eric', 'Rain']
>>> names[1:-1] #取下标1至-1的值，不包括-1
['Tenglan', 'Eric', 'Rain', 'Tom']
>>> names[0:3] 
['Alex', 'Tenglan', 'Eric']
>>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
['Alex', 'Tenglan', 'Eric']
>>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy'] 
>>> names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
>>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
['Alex', 'Eric', 'Tom'] 
>>> names[::2] #和上句效果一样
['Alex', 'Eric', 'Tom']

追加

>>> names = ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新来的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

插入

insert(index, p_object):

names = ['benjie','jack','alex']
names.insert(2,"新人")
print(names)  #  ['benjie', 'jack', '新人', 'alex']

删除

del names[0]  # 删第一个元素['jack', '新人', 'alex']

修改

names = ['benjie','jack','alex']
names[1] = "新换的" # ['benjie', '新换的', 'alex']

扩展

L.extend(iterable) -> None -- extend list by appending elements from the iterable

拷贝

names = ['benjie', 'jack', 'alex']
name_copy = names.copy()
print(name_copy) #  ['benjie', 'jack', 'alex']

统计

L.count(value) -> integer -- return number of occurrences of value

排序和翻转

>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.sort() #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了，擦
>>> names[-3] = '1'
>>> names[-2] = '2'
>>> names[-1] = '3'
>>> names
['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']
>>> names.sort()
>>> names
['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

>>> names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']

获取下标

names = ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
>>> names.index("Amy")
2 #只返回找到的第一个下标

元组（tuple）

只读列表。有序

特性：一旦创建不能修改。元组用来存放一些希望不被改变的值.

两个方法：count，index

tuple_test = ("alex","ben","alex","benjie")
print(tuple_test.index("alex"))  # 0  获取该元素第一次出现的位置
print(tuple_test.count("alex"))  # 2

集合（set）

无序，元素不重复。

s = set([1, 2, 3])
>>> s
{1, 2, 3}

传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。

特性：

去重
关系测试：交集，差集，并集等

# -*- coding: utf-8 -*-
# Author:benjamin
# Date: 3.3

'''
list_1 = [1,4,5,7,6,7,8,3]
list_1 = set(list_1)
list_2 = set([2,5,6,0,66,22,8])
print(list_1 | list_2)#并
print(list_1 & list_2)#交
print(list_1 - list_2)#差集
print(list_1 ^ list_2)#对称差集
'''

list_1 = [10,7,5,7,6,7,8,3,2]
list_1 = set(list_1)
# 打印集合，自动去重；
print(list_1,type(list_1))
# {2, 3, 5, 6, 7, 8, 10} <class 'set'>

# 无序
list_2 = set([2,5,6,0,66,22,8])
print(list_1,list_2)
# {2, 3, 5, 6, 7, 8, 10} {0, 2, 66, 5, 6, 8, 22}

# 交集
print(list_1.intersection(list_2))  # {8, 2, 5, 6}

# 并集
print(list_1.union(list_2))  # {0, 2, 3, 66, 5, 6, 7, 8, 10, 22}
# 差集 in list_1 but not in list_2
print(list_1.difference(list_2))  # {10, 3, 7}
# 子集
print('list_1 is subset list-2',list_1.issubset(list_2))  # False
print('list_1 is superset list_2',list_1.issuperset(list_2))  # False

list_3 = set([2,7])
print(list_3.issubset(list_1))  # True
print(list_1.issuperset(list_3))  # True

# 对称差集 返回一个新的 set 包含 list1和 list2中不重复的元素
print(list_1.symmetric_difference(list_2))  # {0, 66, 3, 7, 22, 10}

# Return True if two sets have a null intersection.
print(list_2.isdisjoint(list_3))  # False

# 增
list_1.add(99)
print(list_1)
# 增一组
list_1.update([33,22,56])
print(list_1)  # {33, 2, 3, 99, 5, 6, 7, 8, 10, 22, 56}

# 判断元素是否在集合中，用于条件判断
print('元素在list_1', {3333} in list_1)

print(list_1)  # {33, 2, 3, 99, 5, 6, 7, 8, 10, 22, 56}
print(list_1.pop())  # 33
print(list_1.discard('7'))  # None
print(list_1.discard('ssss'))  # None
print(list_1.remove(8))  # None

字典(dict)

key-value形式，无序，key唯一。

增
删

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：
改

查

1. key in dict
2. dict.get(key):方法不存在返回none 推荐使用

# -*- coding: utf-8 -*-
# Author:benjamin
# Date:
# 字典是无序的，输出不一定，通过key来取出。
#
info = {
    'n1': '小明',
    'n2': '小红',
    'n3': '小张'
}
info1 = info
# 增
info['n4'] = '小来'
print(info)
# 删
info.pop('n4')
print(info)
# del 删
del info['n2']
print(info)
# 随机删
info.popitem()
print(info)

info = {'n1': '小明', 'n2': '小红', 'n3': '小张'}
# 改
info['n3'] = '呵呵'
print(info)

# 查
print('n3' in info)  # True
print(info.get('n4'))  # None get方法不存在返回none
# print(info['n6'])#Traceback (most recent call last): KeyError: 'n6' key不存在会报错

# 遍历
for i in info:
    print(i, info[i])
# 会先把dict转成list，数据大时莫用
for k, v in info.items():
    print(k, v)

# values
print(info.values())  # dict_values(['小红', '小明', '呵呵'])
# keys
print(info.keys())  # dict_keys(['n2', 'n1', 'n3'])
# setdefault
# D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
info.setdefault('n10', 'alex')
print(info)

# update
b = {
    1: 2,
    3: 4,
    'stu1101': 'tenglan wu'
}
info.update(b)
print(info)

文件操作

操作流程

打开文件，得到文件句柄并赋值给一个变量

文件句柄=open(‘文件路径‘，‘模式’)
通过句柄对文件进行操作

read

readline
关闭文件

close

模式

r，只读模式（默认）。
w，只写模式。【不可读；不存在则创建；存在则删除内容；】
a，追加模式。【可读；不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

r+，可读写文件。【可读；可写；可追加】
w+，写读
a+，同a

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）b(rb,wb,ab)模式：不用加encoding:utf-8

with语句

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

with open("文件名","打开方式") as f:
    操作

文件修改

import os
with open('a.txt','r',encoding='utf-8') as read_f,        open('a.txt.swap','w',encoding='utf-8') as write_f:
    for line in read_f:
        write_f.write(line)

os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')