博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
Python复习 一
阅读量:5100 次
发布时间:2019-06-13

本文共 13565 字,大约阅读时间需要 45 分钟。

Python回炉复习 1

变量

Python的变量和C语言的变量书写方式类似;

书写要求

python程序编写结构利用缩进表示,抛弃花括号;

结构

分支:

if(条件语句1):    执行语句块else if(条件语句2):    执行语句块else:    执行语句块

循环:

while 循环

while 循环条件:    循环语句体

for 循环

for 目标 in 表达式:    循环语句体

表达式的结果会和目标联成共体

  • range()函数:

步长函数;

range(x,y,z)

​ x:开始

​ y:结束(y-1)

​ z:步长

  • break 语句:

跳出当前结构体

  • continue 语句:

结束以此循环体的运行

列表

创建列表

>>> num = [1,2,3,4,5] // 列表创建>>> num               // 列表输出[1, 2, 3, 4, 5]>>> num = ['Hello','你好',666]>>> num // 列表支持各种类型,除数字以外的其他字符都需要用单引号['Hello', '你好', 666]

append():添加元素

>>> num.append(6)>>> num[1, 2, 3, 4, 5, 6]

extend():添加多个元素

>>> num.extend([7,8,9])>>> num[1, 2, 3, 4, 5, 6, 7, 8, 9]

append()是添加一个单独的元素,就是简单的扩充;

而extend()则是将原有的列表和自己要添加的列表拼接成一个新列表

insert():在列表中插入元素

>>> num.insert(0,0) // 在0索引位置添加元素0>>> num[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

pop():删除列表元素

  • php():删除列表最后一个元素
  • php(X):删除列表中索引为X的元素
  • pop()会返回被删除的元素内容
>>> num.pop()9>>> num.pop(0)0>>> num[1, 2, 3, 4, 5, 6, 7, 8]

del 语句:删除列表

  • del [ListName]:删除整个列表(也可以同时删除多个)
  • del [ListName[X]]:删除索引为X的元素
>>> num = [1,2,3,4,5,6,7,8]>>> num[1, 2, 3, 4, 5, 6, 7, 8]>>> del num[7]>>> num[1, 2, 3, 4, 5, 6, 7]>>> del num>>> numTraceback (most recent call last):  File "
", line 1, in
numNameError: name 'num' is not defined

如报错提示:num不存在

remove():删除已知X元素

  • 搜索元素X内容并删除

我们之前的del语句和pop()函数都是依靠列表的索引来删除索引下的元素,remove()则是不靠索引,而是根据元素的具体内容来删除。

>>> num = ['Hello','你好',666]>>> num['Hello', '你好', 666]>>> num.remove(666)>>> num['Hello', '你好']>>> num.remove('你好')>>> num['Hello']

列表分片

将一个列表只输出或显示或复制一部分数据元素,就是所谓的列表分片

>>> num = ['HUAWEI',"CHINA",'Mirror','XIAOMI']>>> num['HUAWEI', 'CHINA', 'Mirror', 'XIAOMI']>>> num[0:1]['HUAWEI']>>> num[0:2]['HUAWEI', 'CHINA']>>> num[0:4]['HUAWEI', 'CHINA', 'Mirror', 'XIAOMI']>>> num[:2]['HUAWEI', 'CHINA']>>> num[:]['HUAWEI', 'CHINA', 'Mirror', 'XIAOMI']>>> num[2:]['Mirror', 'XIAOMI']

仔细观察,发现分片的[x:y]是左闭右开的范围(原则)【python里很多时候和范围有关的闭合问题都是左闭右开的原则】

同时,分片机制还支持省略范围值;即左为空则从0开始,右为空则到最后一个元素结束,左右皆为空则全部元素输出;

分片的高级玩法

大家都认为分片只有两个参数?

分片有三个参数 ==> [x:y:z]

​ x:开始

​ y: 结束

​ z: 步长(即每次递加的数量为z也可以理解为数学中的等差概念)

>>> num = [] // 创建一个空数组>>> for i in range(1,10):    num.append(i)>>> num[1, 2, 3, 4, 5, 6, 7, 8, 9]>>> num[0:10:2][1, 3, 5, 7, 9]

深浅复制初讨论

>>> list = [1,2,3,4]>>> copy = list>>> copy1 = list>>> copy2 = list[:]>>> copy1[1, 2, 3, 4]>>> copy2[1, 2, 3, 4]

从上边可以看出,list直接复制和list[:]分片复制的结果一样,但其实暗藏心急哦!

>>> list.append(5)>>> copy1[1, 2, 3, 4, 5]>>> copy2[1, 2, 3, 4]

向原来的源列表 append() 添加一个元素,发现copy1的内容和list源列表一同别改变(append()操作)

  • 解释:

copy1 = list : 属于将list的内存地址给了copy1,

copy2 = list[:]:属于将list的值给了copy2

列表比较

列表支持比较运算符的比较操作:

>>> list1 = [123]>>> list2 = [234]>>> list3 = [123]>>> list1 < list2True>>> list1 <= list3True>>> list1 == list3True>>> list1 != list2True>>> list1.append(234)>>> list2.append(123)>>> list1[123, 234]>>> list2[234, 123]>>> list1 > list2False

两个列表的比较是根据ASCII值的大小比较的,如果遇到两个元素,则比较第一个,若第一个相同在比较第二个元素。

字符串列表

拼接和重复

>>> str1['HUAWEI']>>> str2['CHINA']>>> str1 + str2['HUAWEI', 'CHINA']>>> str1 * 3['HUAWEI', 'HUAWEI', 'HUAWEI']>>> str1 = str1 +str2>>> str1['HUAWEI', 'CHINA']>>> str1[1] * 3'CHINACHINACHINA'

元素判断:in/not in

  • 判断元素是否存在列表中:’str‘ in List / ’str‘ not in List
>>> str1['HUAWEI', 'CHINA']>>> "CHINA" in str1True>>> "CHINA" not in str1False

元素查询

index():查询元素的索引

>>> str = ["H","U","A","W","E","I"]>>> str['H', 'U', 'A', 'W', 'E', 'I']>>> str.index("I")5>>> str.index("K")  // 元素不存在保存Traceback (most recent call last):  File "
", line 1, in
str.index("K")ValueError: 'K' is not in list>>>

count():查询元素重复次数

>>> list[3, 4, 5, 2, 5, 66, 7, 2, 5, 7]>>> list.count(5)3

排序:reverse() 、sort()

  • reverse():反向排列
  • sort():升序排列
>>> list[3, 4, 5, 2, 5, 66, 7, 2, 5, 7]>>> list.reverse() // 反向排列>>> list[7, 5, 2, 7, 66, 5, 2, 5, 4, 3]>>> list.sort()   // 升序>>> list[2, 2, 3, 4, 5, 5, 5, 7, 7, 66]>>> list.reverse()  // 反向排列 (srot+reverse ==> 降序)>>> list[66, 7, 7, 5, 5, 5, 4, 3, 2, 2]

元组

元组可以理解为:一旦定义不可被更改的列表。

元组创建

>>> tuple = (1,2,3,4,5)>>> number = [1,2,3,4,5]>>> tuple(1, 2, 3, 4, 5)>>> number[1, 2, 3, 4, 5]

tuple是元组,number是列表;

可以发现;两者的定义有所不同

元组是由圆括号组成的一组列表数据,列表是由方括号组成的一组数据

元组访问

元组的访问方法和列表是一样的,主要通过元组的索引来访问元组的元素,和列表一样可以通过分片(切片)的方式访问。

>>> tuple(1, 2, 3, 4, 5)>>> tuple[2]3>>> tuple[3]4>>> tuple[:](1, 2, 3, 4, 5)

type() 方法

  • 返回参数的类型
>>> tup = ()>>> num = []>>> type(tup)
>>> type(num)

很多时候,都会认为圆括号定义的列表数据就是元组,然而并不是!

>>> del tup>>> tupTraceback (most recent call last):  File "
", line 1, in
tupNameError: name 'tup' is not defined>>> tup = 1,2,3,4>>> type(tup)

没错,没有圆括号的列表数据也是tuple元组。

定义元组的特点是:逗号

>>> (6)*636>>> (6,)*6(6, 6, 6, 6, 6, 6)

所以在元组的定义时候,需要一个逗号告诉程序,这是元组

>>> tup = (1,2,3,)>>> type(tup)

这是最标准的定义方法,为什么?

元组更新与删除

  • 更新:

元组和列表的功能除了数据改变以外几乎一致,一个元组的数据是不可以改变的,但元组和元组之间是可以拼接的

>>> tup(1, 2, 3)>>> tup = tup[:3] + 4, + 5,Traceback (most recent call last):  File "
", line 1, in
tup = tup[:3] + 4, + 5,TypeError: can only concatenate tuple (not "int") to tuple>>> tup = tup[:3] + (4,) + (5,6,)>>> tup(1, 2, 3, 4, 5, 6)

tup利用拼接将tup元组数据进行了更新;

注意:

​ 这里在拼接的时候,将拼接的内容均用括号和逗号等标志表示这是一个元组数据,否则会被程序认为是一个字符或者数字数据。

逗号是元组的标志定义

  • 删除:
>>> tup = tup[:2] + tup[4:]>>> tup(1, 2, 5, 6)

通过拼接方法覆盖掉需要删除的元素,以此达到删除元素的目的。

  • 总结:

元组的数据是不变的,但是元组可以和列表一样自由的拼接:

​ 利用末尾的切片拼接的方式让元素增加元素(注意元组元素逗号标识)

​ 利用分片拼接的方式切除删除元素的前后内容拼接成一个新的元组

字符串

  • Python3的所有字符串都是Unicode(编码)字符串

创建

>>> char = "HUAWEI">>> str = 'XIAOMI'>>> char'HUAWEI'>>> str'XIAOMI'

字符串的创建可以使用单引号和双引号

字符串修改

>>> str = str[:3] + "-" + str[3:]>>> str'XIA-OMI'

字符串的修改和元组类似,采用分片拼接的方式实现更改字符串内容。

ps:是重新组成新的字符串给一个新的字符串变量所以要赋值

字符串格式化

format()

  • 按照索引坐标
>>> '{0}-{1}={2}'.format('XIAOMI','HUAWEI','CHINA')'XIAOMI-HUAWEI=CHINA'

从代码中可以看出,字符串中的花括号内容是对应这format方法的参数值索引内容,通俗说:花括号里的索引会将format中的对应的参数值调用组成一个字符串。{format中的参数称为:位置参数}

  • 按照(关键字)键值对
>>> '{x}-{h}={c}'.format(x='XIAOMI',h='HUAWEI',c='CHINA')'XIAOMI-HUAWEI=CHINA'
  • 注意:位置参数索引要放在关键字索引前面

格式化操作

格式化操作符

格式符号 描述
%c 格式化字符以及ASCII
%s 格式化字符串
%d 格式化整数(十进制)
%o 格式化无符号八进制
%x 、%X 格式化无符号十六进制(小写、大写)
%f 格式化浮点数
%e 、%E 格式化科学计数法浮点数

以上为常见的格式符号操作;和C语言异曲同工。

格式化操作书写

'[格式化操作符]' % [需要格式化操作的内容]
>>> '%c' % 99'c'

格式化操作的表达方式是:百分号 ==> %

辅助参数

参数命令 描述
m.n m为最小从宽度,n为小数点后的位数
- 左对齐
+ 证书前显示加好
# 在八进制和十进制结果中分别显示:0o 和 0x/0X
0 数字前面用”0“填充空格
转义字符 描述
 ' 单引号
 " 双引号
 a 系统响鸣
 b 退格符
 n 换行符
 t ,  v 制表符(8个空格)
 f 换页符
 r 回车符
 \ 反斜杠
 0 代表一个空字符

序列

  • 列表、元组、字符串(*)都可以视为可迭代对象

list():可迭代对象转为列表

>>> list = list((1,2,3,4))>>> list[1, 2, 3, 4]>>> list = list("HUAWEI")>>> list['H', 'U', 'A', 'W', 'E', 'I']

tuple():可迭代对象转为元组

>>> tuple = tuple("HUAWEI")>>> tuple('H', 'U', 'A', 'W', 'E', 'I')>>> type(tuple)

str():obj对象转为字符串

>>> s = str(1)>>> s'1'>>> type(s)
>>> tuple(s)('1',)

len(sub):返回参数长度

>>> num = [1,2,3,5,6,7]>>> len(num)6

max()/min():序列最大/最小值

>>> num = [1,2,3,5,6,7]>>> len(num)6>>> max(num)7>>> min(num)1

sum():返回总和

>>> num = [1,2,3,5,6,7]>>> sum(num)24

sorted():排序

>>> num[12, 24, 33, 32, 243, 3, 6, 23, 15, 7, 6, 5, 3, 2, 1]>>> sorted(num)[1, 2, 3, 3, 5, 6, 6, 7, 12, 15, 23, 24, 32, 33, 243]>>> num[12, 24, 33, 32, 243, 3, 6, 23, 15, 7, 6, 5, 3, 2, 1]>>> num.sort()>>> num[1, 2, 3, 3, 5, 6, 6, 7, 12, 15, 23, 24, 32, 33, 243]

代码中我们和前面的sort()进行了对比发现

​ sorted():返回升序后的结果但不改变原有数据

​ sort():将源列表进行了升序

reversed():逆向迭代

>>> list = list((2,4,67,3,7,3,8))>>> for i in reversed(list):    print(i,end='-')8-3-7-3-67-4-2-

可以看出,reversed()方法会将一个可迭代的序列逆向迭代输出

enumerate():生成二元组

二元组:元素为2的元组构成一个迭代对象,每个二元组有迭代参数的索引和对应的元素组成。

>>> for i in enumerate(list):    print(i)    (0, 'H')(1, 'U')(2, 'A')(3, 'W')(4, 'E')(5, 'I')

zip():迭代参数合为元组

返回可迭代参数共同组成的元组

>>> list[2, 4, 67, 3, 7, 3, 8]>>> str['H', 'U', 'A', 'W', 'E', 'I']>>> for i in zip(list,str):    print(i)    (2, 'H')(4, 'U')(67, 'A')(3, 'W')(7, 'E')(3, 'I')

函数

函数创建、调用

函数的含义就是将需要的且重复的功能代码封装在一个对象函数中,需要使用的时候直接调用即可。

def out():    print("Hello,World!")    print("I am Mirror")    out() // 调用out函数Hello,World!I am Mirror

函数参数

在函数定义的时候,可以在括号内添加参数设置,为函数设置参数,在调用函数时就会要求传入参数,函数体内也可以引用这个参数值进行工作。

def name(s):    print(s)def sum(x,y):    print(x+y)name("Mirror")sum(1,2)================ RESTART ================Mirror3

函数可以接收零个或多个参数值,在函数定义的时候,参数的数据类型可以不定义

函数返回值

def name(s):    return "I am {0}".format(s)def sum(x,y):    return "SUM = {0}".format(x+y)print (name("Mirror"))print (sum(1,2))================ RESTART================I am MirrorSUM = 3

灵活的函数

形参和实参

从上例函数的参数认识到了参数的设置和传递,但是如果我们不知道我们传递多少个数据参数的时候怎么办?

  • 形参:函数创建时的参数定义
  • 实参:函数调用过程中有调用出传递的参数

函数文档

  • 指在函数定义下方注明函数的具体作用,增加可读性

一般情况下,在嗲吗开头的三引号里不会打印出来,但是依旧会被存储,和注释的功能非常的类似,我们可以在调用的时候获取这个三引中的内容,了解函数的作用

_ _ doc _ _:获取函数
def sum(x,y):    """ 返回 x,y 的求和"""    return "SUM = {0}".format(x+y)print (sum.__doc__)================ RESTART ================ 返回 x,y 的求和

关键字函数

def sum(x,y):    """ 返回 x,y 的求和"""    return "SUM = {0}".format(x+y)print (sum(x=1,y=2))

将形参的名称作为关键字,采用”赋值“模式对指定的形参传递实参

默认参数

def sum(x=1,y=2):    """ 返回 x,y 的求和"""    return "SUM = {0}".format(x+y)print (sum())

默认参数:函数定义形参的同时给形参设置一个默认的参数,如果函数调用时为接收到实参传递则使用形参的默认参数进行运行

可变参数

回到形参时提出的关于不知道传递参数:

从上例函数的参数认识到了参数的设置和传递,但是如果我们不知道我们传递多少个数据参数的时候怎么办?

这时候就需要我们设置一个可变的形参(参数):

* 形参名

def sum(* s):    print(len(s))    print(type(s))sum(1,2,3,4,5,6,7)================ RESTART ================7

观察分析得出:使用星号表示的形参会自动将接收的实参序列压缩为一个”元组“,我们在没有使用可变参数的时候只可以传递单个(数字、字符、字符串)参数

  • 可变参数可以接收的是:可迭代的序列(列表,元组,字符,字符串……)

字典集合

  • python的字典集合采用:(Key:Value)键值对进行保存、读取等操作

字典创建(dict)

>>> dict = {1:10086,"a":"CHINA"}>>> dict{1: 10086, 'a': 'CHINA'}>>> dict[1]  // 根据Key索引并返回Value10086>>> dict["a"]'CHINA'

字典的标志特点就是:花括号包围的键值对序列

  • Key:是独一无二的,在同一个字典集合中不会重复
  • Value:每一个Value对应一个Key,Value可以重复,但必须不可变

字典内置操作

formkeys():创建返回新字典

  • 参数:
    • key:必须
    • Value:默认None
>>> del dict>>> dict.fromkeys((1,2,3)){1: None, 2: None, 3: None}

返回字典内容

keys():返回字典所有Key值
>>> dict{1: None, 2: None, 3: None}>>> dict.keys()dict_keys([1, 2, 3])
values():返回字典所有Value值
>>> dict.values()dict_values([None, None, None])
items():返回字典所有项
>>> dict.items()dict_items([(1, None), (2, None), (3, None)])

get():查询一个key的value

>>> dict{1: 10086, 'a': 'CHINA'}>>> dict.get("a")'CHINA'>>> dict.get(1)10086>>> dict.get("CHINA")>>> dict.get(112)

get()查询一个key,如果不存在不会返回报错!可以利用 in/not in 来实现判断是否存在

claer():清空字典

>>> dict.clear()>>> dict{}

ps: 是清空内容不是删除

copy():复制字典

>>> dict{1: 10086, 'a': 'CHINA'}>>> c = {} // 定义一个空字典>>> c{}>>> type(c)
>>> c = dict.copy()>>> c{1: 10086, 'a': 'CHINA'}

pop():弹出(删除)值

  • pop(key):删除key和对应的value
  • popitem():删除最后一个key和value
>>> dict = {1:10086,"a":"CHINA"}>>> dict.pop(1)10086>>> dict{'a': 'CHINA'}>>> dict = {1:10086,"a":"CHINA"}>>> dict.popitem()('a', 'CHINA')>>> dict{1: 10086}

update():更新字典

  • dict.update(dict)
>>> dict.update({2:2019})>>> dict{1: 10086, 'a': 'CHINA', 2: 2019}

集合创建(set)

  • 先看dict和set的区别
>>> dict1 = {}>>> dict2 = {1,2,3,4,5} // 集合创建>>> type(dict1)
>>> type(dict2)

可以通过集合与字典的比较发现集合的特点:

​ 集合是使用花括号但不适用键值对,以逗号分隔的序列

  • 集合开始
>>> set = {1,2,3,4,5,6}

访问集合

>>> set1{1, 2, 3, 4, 5, 6}>>> for i in set1:    print(i,end=" ")1 2 3 4 5 6

Python文件

文件打开 open()

操作符

标志 描述
r 以只读方式打开文件
w 以写入方式打开文件
x 文件存在会抛出异常
a 以写入方式打开,已存在文件可追加
b 以二进制打开文件
t 以文本方式打开
+ 可读写模式
U 通用换行符支持

open()函数

open():用于创建一个文件对象,以便其他操作使用该文件对象

  • 单参数:可以是文件的具体路径和文件名(如果只是文件名会索引当前目录)
  • 操作符:决定文件的打开模式(默认为只读 ”r“)

操作函数

close():关闭文件

read():读取字符

  • read(size=-1):从文件中读取size指定的字符内容大小;未赋值表示读取全部内容并作为String返回

readline():读取一行字符串

write():向文件输出内容

writelines():向文件输出序列

seek():移动文件指针

  • seek(offset,form):从form偏移offset字节
    • offset:0 = 起始;1 = 当前位置;2 = 末尾

tell():返回当前文件的位置

OS 文件模块

os模块;import os 导入os模块

目录操作

getcwd():获取当前目录
chdir():切换目录
listdir():查看任意目录内容
mkdir():创建文件夹(目录)
makedirs():创建多级文件夹(目录)

删除操作

remove():删除指定文件
radir():删除指定文件夹(目录)
removedirs():删除多级文件夹(目录)
rename():文件/文件夹 重命名

系统操作

system():调用工具
walk():遍历子目录返回三元组

path 路径操作

path.basename():获取文件名
path.dirname():获取路径名
path.join():完整路径join
path.split():分隔路径和文件名
path.splitext():分隔文件名和扩展名
path.getsize():获取文件大小(字节)

path 时间函数

path.getatime():最近访问时间
path.getctime():创建时间
path.getmtime():修改时间

prckle()模块

可以将对象以文件的形式存放在磁盘中;是一种简单的持久化功能

python的所有数据类型都可以使用 prckle()来序列化存放磁盘

异常处理

AssertionError:断言

assert在测试程序的时候,在代码植入检查点

>>> list = ['Mirror']>>> assert len(list)>0>>> list.pop()'Mirror'>>> assert len(list)>0Traceback (most recent call last):  File "
", line 1, in
assert len(list)>0AssertionError

assert断言:在其语句后面的条件成立的时候则不会编译assert,若断言条件满足后则会在程序中报错。

如上例代码程序:原先list列表内有一个元素,assert没有报错,但是pop方法弹出(删除)元素后,assert的条件得不到满足就会报错

try - except语句

try:    检测范围except exception[as e]:    检测发现exception异常后的处理方法finally:// 可选    必须执行的代码块
  • 范例:
>>> try:        file = open("a.txt")        file.close()    except OSError:        print("Error")    Error

如范例中的程序,检测到在调用file文件对象的时候发生了OSError错误,由此执行报错(异常)代码执行块

>>> try:        file = open("a.txt")        file.close    except OSError as e:        print(str(e) + "Error")    except TypeError as e:        print(str(e) + "Error")    [Errno 2] No such file or directory: 'a.txt'Error

如上;利用as error方法,将错误信息写入e变量中,在以str的类型输出错误信息;同时发现,可以定义多种不同的错误类型和报错输出。

异常

Exception: 所有异常的基类(可以接收任何类的异常)

AssertionError:assert语句失败(assert条件不成立)

AttributeError:访问一个对象没有的属性(对象属性不存在)

IOError:输入输出操作异常

ImportError:无法引入模块或包(路径错误等)

IndexError:索引超出序列边界

KeyError:访问字典中不存在的key

KeyboardInterrupt:Ctrl+C被触发

NamError:使用的对象无变量

SyntaxError:代码逻辑语法错误

TypeError:对象类型和语句要求不符

UnboundLocalError:全局变量的异常

ValueError:传入的value值异常出错

ZeroDivisonError:触发除零的异常

第三方GUI模块:EasyGUI

类和对象

认识类和对象

类:class 类名称:

对象:def 方法名():

一个程序可以由多个类组成,一个类由多个对象方法组成;

self关键字:代表自己的对象参数

类的方法与普通的函数只有一个区别:它们必须有一个额外的参数名称,但在调用这个方法的时候不可以为这个参数赋值,python会提供这个值。这个特别的变量指的是对象的本身,名为:self;

初探Python魔法方法

__ init__()构造方法

只要实例化一个对象前,这个方法就会在对象被创建前自动调用;参数形参也会自动传入该方法中;可以利用重写该方法实现初始化的操作

class Potate:    def __init__(self.name):        self.name = name    def kick(self):        pirnt(self.name)

公有和私有

public :公有、公共

private:私有

以上是C++和Java方法;

在Python中表示私有的属性:变量名前两个下划线“__”

继承

class 类名(被继承的类):
  • self:只可以使用自己的类中的对象
  • super:可以从子类中调用父类中的属性对象

Python支持多重继承,即一个类继承多个父类;【不建议使用】

转载于:https://www.cnblogs.com/wangyuyang1016/p/11260913.html

你可能感兴趣的文章
linux下调整java版本
查看>>
AutoCAD实用技巧基础篇
查看>>
Junit测试工具
查看>>
ubuntu 系统环境配置记录
查看>>
C# 流总结
查看>>
org.apache.hadoop.mapreduce.lib.input.InvalidInputException: Input path does not exist: file:/input
查看>>
jumpserver安装与部署
查看>>
Apache,php配置
查看>>
Python特殊语法:filter、map、reduce、lambda
查看>>
vs2008 此安装不支持该项目类型
查看>>
C# Hash算法
查看>>
转:C语言深度剖析三
查看>>
HDU 2095 find your present (2) 异或
查看>>
swipe滚动失效
查看>>
线程间操作无效: 从不是创建控件的线程访问它。
查看>>
WebStorm+Chrome调试Vue步骤
查看>>
PAT (Basic Level) Practise (中文)- 1022. D进制的A+B (20)
查看>>
数据类型和变量
查看>>
服务端的GET、POST请求
查看>>
Python之文件操作工具
查看>>