print

一个print里输出多变量，输出的用空格连接

一个print默认最后输出一个 end=‘\n'

格式化字符串写法为 'xxx%dxxx%sxxx'%(变量名)，只有一个变量可省略括号

print利用格式化字符串就可以实现格式化输出，但注意和C++printf还是有区别，因为你是用格式化字符串，而不是print自己是格式化，换言之print还是自己的语法，end='\n'还是有的

type

python三大基本类型 int, float, str 可以相互转换

需要注意和Java不同，str 只能和 str 拼接，所以想和 int 拼接要转 str

如果 str 内容是 float，转 int 会报错，内容是 int，转 float 是可以的，类似于隐式转换思想，只能向高位转换

eval() 函数可以识别类型，自动确认 str 转成 int 还是 float

python支持单语句多变量赋值，换言之就是逗号连接的多变量和tuple，list等是可以转换的，eval在这种场景下十分好用

str的识别分割看的是逗号，所有空格都会直接被 strip 掉，行末可以有若干 \n

当然 eval 还有别的用途，学习的意义不大就不说了

input

python输入只能 input 一整行字符串

可以对字符串操作再强制类型转换来得到我们想要的数据

基本运算

python没有自增运算，只能 a+=1

其他该有的都有

python独有的幂运算 **，例如 4**2，4**0.5

注意python除法不是看类型的，用整除和浮点除区分

整除 // ，浮点除 /

if

python的 if 语法为 if，elif，else

高级用法是 if...in...: 实现了C++find的功能，可作用于任何容器，比如 list，str 都行

还要注意的是 python 没有 && || ! 这些，要用 and or not

while

python也有continue和break

比较特别的是 while else，for else 用法

进入 else 语句的条件是 while 的判断语句判断为否

换言之可以理解为，while正常完成了就会进入else，break无法进入else

for...in...

需要注意的是下面那个 i+=2 不能实现输出 1，3，5，7，9

因为 i 是每次从 range 中取一个，这和 C++ 的局部变量有很大区别的，可以理解成C++11的auto访问容器元素

...if...else...三目运算符

A if P else B

P成立就返回A，否则返回B

值得一提的是，Python 判断真假和 C++ 是一样的，非零则真，零则假，也可用 True 和 False 参与比较

不像 Java 必须和 True False 比较

import

Python的封装格式为包.模块.属性

包就是文件夹，可以由一系列子包构成

模块可以是 .py 文件，可以是DLL，C++扩展等，需要注意的是 ipynb 不行

属性是函数、变量、类等等

如图的文件结构是，main.py在项目根目录下，testpy.py的路径是根目录下的 com.test 下，有函数 fun()

有两种引入方法 import... 和 from...import...

其用法特点是，

单独的 import 必须引入模块，调用时必须调用 import 引入的整个成分

from import 必须 from 包 import 模块或者 from 模块 import 属性，调用时只需从 import 引入的整个成分开始调用，不用管 from 的部分

还需注意的是只有 from 模块 import * 才可以用 *，引入该模块下所有属性

具体用法如下图所示

另外还可以对引入的部分用 as 更名

是对 import 的整个部分更名

使用起来会方方便许多

具体用法如下图所示

Python3内置函数

像 input、print 这种就是内置函数

Python3 有很多内置函数

详见 https://docs.python.org/zh-cn/3/library/functions.html#bool（python3）、https://www.runoob.com/python/python-built-in-functions.html（python2，但是写的很好）

一些有价值的用法会在下面进一步列举强调

abs、format、chr、enumerate、hash、help、len、min、max、map、ord、pow、reversed、round、sum、sorted

需要注意的是没有 swap，为什么呢

a,b = b,a 这样就行，甚至一堆变量你都可以轻松乱换

abs

format：和字符串的%类似，但写法不同且功能更高级一些

chr

enumerate

hash：对象hash只和内存地址有关

help

map

ord

pow：不传模p，那就和 ** 一样，但是好处在于有快速幂取模功能

reversed

round：四舍五入

sum

sorted：后面会单独讲更高级的用法，有关于多关键字多级排序的处理

math

注意 python math 是与 float 相关的数学计算，比如他没有 abs divmod 这种，但它有 fabs fmod，不过参数毕竟隐式转换，传 int 也没事

math 模块的函数所有返回值都是 float 类型，一定要注意

像 pi e nan cos acos sqrt pow log exp floor ceil fabs fmod fsum等等这种就不多说了，说一些不常见的

comb(n,m) 计算组合数，例如 math.comb(5,2) = 10

dist([P],[Q]) 计算两点距离，例如 math.dist([0,0,0],[1,1,1]) = 1.732

degrees(x) 弧度转角度，例如 math.degrees(math.pi) = 180.0

radians(x) 角度转弧度，例如 math.radians(180) = 3.1415926

expm1(x) 计算 e^x-1，比 math.exp(x) - 1 更准确

log1p(x) 计算 log(x+1)，比手动准确

math.inf 真正意义上的 inf

math.erf(x) (高斯)误差函数

math.erfc(x) 互补误差函数

math.frexp(x) 返回 tuple(m,e)，满足 m * (2**e) = x，m 是浮点数且 e 最小

math.ldexp(x,i) 计算 m * (2**I) ，比直接做准确

math.factorial(x) 计算 x 的阶乘 x!

math.gcd(x,y) 最大公约数

math.lcm(x,y) 最小公倍数

math.gamma(x) 伽马函数

math.hypot() 欧几里得范数，实际上就是勾股定理求斜边，例如 math.hypot(3,4) = 5

math.isinf，math.isnan，math.isfinite 字面义

math.modf(x) 看清不是 fmod，作用是拆分整数和小数部分为元组，例如 modf(3.14)=(0.14,3.0)

math.tau = 6.283185307179586

complex复数

写法很简单，a+bj

注意 1 的时候要写 +1j 而不是 j

基本运算基本都能做，就不具体说了

cmath复数数学

基本的指数对数三角函数都有，然后要注意关于 nan，inf 还多了 nanj，infj，说一些特别的

cmath.phase(x) 返回复数 x 的相位角 phi，phi 使用弧度制 rad

cmath.polar(x) 返回复数 x 的极坐标形式 (r,phi)

cmath.rect(r, phi) 返回极坐标 (r,phi) 对应的复数 x

cmath.isclose(a, b, rel_tol=1e-09, abs_tol=0.0) a和b比较接近则返回True，否则返回False，rel_tol 是相对容差，abs_tol 是最小绝对容差，认为 NaN 不接近任何值，认为 inf 和 -inf 只接近自己

random

seed(x) 设种子，默认None，调用当前时间，相当于默认就是 C++ 的 srand null

random() [0.0,1.0) 随机 float

uniform(a,b) [a,b] 或 [b,a] 随机 float

randint(a,b) [a,b] 随机 int，要求 a<=b

randrange(a,b,step) 随机从 range(a,b,step) 中取 int

choice(seq) 随机从序列 seq 中取一 ele

choices(seq,weights=None,cum_weights=None, k=1) 随机从序列 seq 取 k 个 ele，返回为seq，其中 weights 是每个 ele 的概率权重seq，也可选用 cum_weights 参数，是权重前缀和seq，注意，取法是放回取样，意味着每个元素都可能重复被取不定次！

shuffle(seq) 把 seq 随机排序，注意！不是返回，而是你传的 seq 被改变

sample(seq,k,counts=None) 和 choices 类似，但这里是每个元素的重复个数 counts，而非权重，注意，区别在于这个是不放回取样，意味着元素最多取counts中的对应个！

以下函数都是从对应随机分布中取一个随机数返回

triangular(low, high, mode) 三角形分布(辛普森分布)

betavariate(alpha, beta) beta分布

expovariate(lambd) 指数分布

gammavariate(alpha, beta) gamma分布

gauss(mu, sigma) gauss分布

normalvariate(mu, sigma) 正态分布

lognormvariate(mu, sigma) 对数正态分布

vonmisesvariate(mu, kappa) 冯·米塞斯分布

paretovariate(alpha) 帕累托分布

weibullvariate(alpha, beta) 威布尔分布

statistics统计

mean(seq) 返回seq的平均数，返回值自动选择 int 或 float

fmean(seq) 返回seq的平均数，返回值为 float

geometric_mean(seq) 返回seq的几何平均数

harmonic_mean(seq) 返回seq的调和均值

median(seq) 返回seq的中位数，是正常算法，偶数个就中间两个相加除2

median_low(seq) 返回seq的低中位数

median_high(seq) 返回seq的高中位数

mode(seq) 返回seq的一个众数，ele可以是str，同样多选顺序的第一个

multimode(seq) 返回seq的众数列表

quantiles(seq) 返回数据的四分位数列表

pstdev(seq) 返回数据的总体标准差

pvariance(seq) 返回数据的总体方差

stdev(seq) 返回数据的样本标准差

variance(seq) 返回数据的样本方差

str

python字符串可以是单引号，双引号和三引号

三引号的特点是用真正的回车代替了\n

str 转 bytes 二进制类型，写法例如 b'abc'

str 是只读类型，和 JAVA String 一样，不能直接改元素

切片：s[start:end:step]，左闭右开，可以用负数，-1表最后一个元素，和 range 等等一样，这些线性序列都是这样

拼接：s1+s2，自拼三个 s*3

需要注意的是，关于下标的函数参数也是可以传负数的

还要注意的是，python str 和 C++ 一样，直接 == 就比较了，str 不是引用类型，不像 JAVA那样需要用 equals

str(object) 强制类型转换

str(object=b'', encoding='utf-8', errors='strict') 将object转str返回，指定后两个参数后便不再是强制类型转换，object此时必须传入二进制类型

s.encode(encoding="utf-8", errors="strict") 返回 s 的指定解码版本

s.capitalize() 返回 s 的第一个字符是字母则大写的版本

s.title() 返回 s 的标题字符串版本，即每个单词首字母大写

s.lower() 返回 s 的小写版本

s.upper() 返回 s 的大写版本

s.swapcase() 返回 s 的所有字母大小写反转版本

s.casefold() 返回 s 的小写版本，不光字母，阿拉伯字符，还有德语等等都会变成小写

s.center(w,c=' ') 返回 str，将 s 补到长度 w 并居中，用 c 补充，补充奇数个则多的那个在右边，w < len(s) 则直接返回

s.ljust(w,c=' ') 同上补齐左对齐

s.rjust(w,c=' ') 同上补齐右对齐

s.count(substr,start=0,end=len(s)) 返回 s 中 substr 的个数，查找范围在 [begin,end)，需要注意！返回的是不重叠次数！例如 'bbb'.count('bb') = 1，'bbbbb'.count('bb')=2

s.startswith(prefix, start=0,end=len(s)) 如果 s[start:end] 的前缀是 prefix 则返回True

s.endswith(suffix, start=0,end=len(s)) 如果 s[start:end] 的后缀是 suffix 则返回True

s.removeprefix(prefix) 如果前缀是 prefix 则返回删除版本

s.removesuffix(suffix) 如果后缀是 suffix 则返回删除版本

s.find(substr,start=0,end=len(s)) 在 [start,end) 查找 substr，找到则返回第一个字符下标，没找到则返回 -1

s.rfind(substr,start=0,end=len(s)) 同上从右开找

s.replace(old,new,count) 返回str版本，找到所有 old 子串替换为 new，指定count则只修改count个

s.isdecimal() 都是阿拉伯数字返回True，反之返回 False，特别的，空串或者没有一个所需查找的对应类型的字符返回False，下同

s.isdigit() 都是数字返回True，包括阿拉伯数字、罗马数字

s.isnumeric() 都是数字返回True，包括阿拉伯数字、罗马数字、汉字数字，汉字的大小写都包括，比如零和〇都算

s.isalpha() 都是字母返回True

s.isalnum() 都是字母或所有类型数字则返回True

s.islower() 都小写字母返回True

s.isupper() 都大写字母返回True

s.istitle() 是标题字符串则返回True

s.isspace() 都空白符则返回True

s.strip(str) 按 str 中的字符消除 s 前后的字符，默认字符列表是空白符

s.lstrip(str) 同上消除左侧

s.rstrip(str) 同上消除右侧

s.partition(str) 按 str 分割，找到一个str开分，返回三元组，str左边部分，str，str右边部分

s.rpartition(str) 同上从右开找

s.split(str,maxsplit=-1) 按 str 分割，全部分割，默认空白符，若指定 maxsplit 则分割有限次，需要注意的是，如果使用默认空白符，不会产生空串！但是人工指定就会正常分割出空串！比如 'aabb'.split('a')，结果是 ['','','bb']

s.rsplit(str,maxsplit=-1) 同上从右开始的版本

s.splitlines(keepends=False) 按 '\n' 分割，keepends可指定是否保留 \n，不产生空串

s.zfill(w) 用0填充前缀成w长度，要注意前缀若为 '+'/'-' 则保持在前缀位置

list

创建方式：

lis=[]

lis=[1,2,3]

len、min、max、分片、拼接等基本用法和 str 一样

需要注意的是不像 str 只读，list 可读可写，对分片赋值即可

分片的赋值要理解成替换，可以替换成更小的，或更大的，要注意元素和序列的对应性

比如

lis[0]=[6,6,6] 则 lis=[[6,6,6],2,3]

lis[0:1]=[6,6,6] 则 lis=[6,6,6,2,3]

注意！！：所有这种可读可写的迭代类型，都和 JAVA 类似，是一种引用

赋值一定要小心！！

如果 lis2 = lis，那么 lis 修改，lis2 也修改，因为指向的是同一个

如果 lis2 = lis[:]，那么就没问题，赋值一定要用分片赋！！

但还要注意，即便这样，内容也是浅拷贝！！比如 lis 里的内容是迭代类型的情况！！

删除的写法：

del lis[i:j:k]

基本运算就可以实现成员函数了，所以大部分成员函数使用意义不大，了解即可

lis.append(x) 尾部追加 x

lis.extend(lis2) 尾部追加迭代类型 lis2

lis.clear()

lis.reverse() 返回逆序副本

lis.sort(reverse=False) 快排，默认False升序

lis.copy() 相当于 lis[:]

lis.remove(x) 删除第一个值为 x 的元素

lis.index(lis2,start,stop) 相当于 find，但是没找到会抛异常，而不是 -1 ，其实 str 也有这个，但不推荐使用

lis.pop(i) 返回 lis[i] 并 del lis[i]

tuple

创建方式：

t=()

t=(1,2,3)

t=1,2,3

tuple 和 list 的一般功能一样，差别在于 tuple 只读

range

创建方式：

range(stop)

range(start,stop,step)

range 几乎啥功能也没有，一般就是用于 for in

其特点是实际存储的只有 start stop step，空间代价极小

dict

创建方式：

dic={}

dic={'a':1,'b':2,'c':3}

dic=dict(a=1,b=2,c=3) 这个方法一般在函数关键字参数那里使用

list 创 dict ：dic=dict(zip(['a','b','c'],[1,2,3]))

二元组列表创 dict ：dic=dict([('a',1),('b',2),('c',3)])

dict 转 list，转的是 key，dict 可以视作一个 key 的迭代序列

keys=list(dic)

for key in dic

知道了 dict 是视作一个 key 的迭代序列

那 min max 这些函数对 dic 的计算结果也就知道是 key 的

del、clear、copy 等等这些很简单也不说了

dic['a'] = 1，这样就可以赋值了，'a' 不存在也可以，但是读值操作就不行了

dic['a'] = dic['a'] + 1 如果'a' 不存在就不行

推荐用 get 函数，写法：dic['e']=dic.get('e',0)+1

键列表 list(dic) 或 list(dic.keys())

值列表 list(dic.values())

键值对二元组列表 list(dic.items())

其他函数，比如 pop 啥的其实真没啥用，这里就不写了

set

创建方式：

st=set() 注意！这个是空集合，而{}是空字典

st={1,2,3}

st=set([1,2,3]) 其中的参数可以是任意迭代类型

set 是去重的，python 没有 multiset

注意！python 的 set 不保证顺序，出现升序是巧合

注意！如果用 set(xx) 创建 set，原理是对迭代类型迭代，所以 set(str) 得到的是单字符字典

frozenset 类型是只读 set，一般也不怎么用

len、in、max、clear 等用法就不说了

st.add(x) 插入 x

st.discard(x) 删除 x，不要用 remove！remove 是不存在则会抛异常

st.pop() 随机弹出一个并返回，没啥用

想要迭代就直接转成 list 就好，处理完想转回来再转回来就行

属于：x in st

相等：st1 == st2

包含于：st1 < st2

真包含于：st1 <= st2

交集：st1 | st2

并集：st1 & st2

相对补集：st1 - st2（在 st1 不在 st2）

对称差集：st1 ^ st2（在 st1 和 st2 不相交的部分）

Def函数

python 的函数非常无脑

参数类型不固定，是啥都行，只要传进去的能做形参那样的操作，就不会抛异常

返回值返不返，返什么也都非常随意

多返回值也就是返回 tuple，也是一个很便利的功能

问题是，不知道参数类型，也就没有成员提示，所以通常会利用注解技术

返回类型也可以注解，如果和注解不一致，就会警告，但是不会报错

写法像下面这样

python的参数比较特别

具体来讲，首先是传实参时可以指定形参名

如下

*args 是确定的 tuple 类型参数，只能接收 tuple 类型实参，称作可变参数

**kwargs 是确定的 dict 类型，只能接收 dict 类型实参，称作关键字参数

* 以后的参数将不确定是否属于 tuple，所以这时候必须指定形参名传实参，称作命名关键字

参数顺序：（默认参数和命名关键字之间不区分顺序）

必选参数、*args可变参数、默认参数/命名关键字、**kwargs关键字参数

需要注意的是，一旦指定了可变参数，那么想要给默认参数传实参，那么必须指定形参名

用法示例：

Class类

python的类比较特别，必须用 self 调实例变量，类似this，必须用 cls 调类变量

python 没有拷贝构造，就像JAVA一样，对象是引用

可以自己随便写个函数来返回副本，就像许多库函数都用 copy() 这个函数

具体讲一下变量和方法：

首先需要注意：python既没有静态变量，也没有常量，比方说 math.pi 是可以改的，但是每次运行它会重新加载，使用构造函数初始化 math.pi 所以不担心改没了

变量：

1.类变量：直接定义在类中的变量，只能被类方法使用

2.实例变量：直接定义在构造函数 __init__(self) 中的变量，只能被实例方法使用

方法：

1.实例方法：含有 self 形参的方法，只能通过 self 调用实例变量，

2.类方法：使用@classmethod装饰器且含有 cls 形参的方法，只能通过 cls 调用类变量

3.静态方法：纯粹的方法，使用@staticmethod装饰器的方法，只能使用方法内变量

注：对象可调用所有三种方法，类可以调用类方法和静态方法，不可调用实例方法

写法示例如下

然后还需要注意的是 python 的类没有成员权限

所以就是类外随便调用

python的继承也非常简单，没重写就是完全用父类的

如果你重写想用父类的，那就直接用父类名，或者super也行，但要注意用实例对象可就不能通过父类名来调用父类函数了

有没有默认构造啥的，和C++不一样，完全没事，毕竟是在构造函数里才定义实例变量

三种调用父类函数的写法如下

class A:def fun(self):pass
class B(A):def fun(self):super(B, self).fun()super().fun()A.fun()

那么，问题来了，多继承是怎样的呢

非常简单，按继承顺序来，重复的话就用顺序第一个父亲的

示例如下

两个 fun，继承顺序是 A,B 于是继承的是 A 的 fun

我们知道 C++ 有一个经典的公共祖先二义性问题，而这个问题在python这种机制下便迎刃而解了，如下代码所示，在python里是完全没有问题，不会有二义性错误的

不过还是需要注意顺序问题

实际上对于这种继承的同名成员的选取

是从下至上的BFS序

如下代码所示，实际上遍历序是 B，C，A，于是用了 C 的 fun

多级排序

对于元组列表，或者对象列表，有时候我们需要多级排序

python 的排序很强的一点是，它有排序稳定性

也就是对于相同 key 的元素，它们将保持原顺序

这样多次去排就可以实现多级排序了

指定元组/对象中的某一个属性来排序，官方推荐的一种写法：使用operator 包下的 itemgetter 和 attrgetter。

当然其实这个我不是很喜欢，还得记包名。

实际上是可以传函数的，这部分详见 Python3 进阶复习的 lambda 表达式篇

代码示例如下：

异常处理

try...except...finally...

具体写法如下：

当然，没人能记住那些乱七八糟的 Error

实际上你程序报错抛异常你就可以看到了，这时候再去处理就好

比如下面这个例子，看报错就能看到 ZeroDivisionError

那么问题来了，finally 存在的意义是什么呢

这就涉及到了一道面试题

面试题1：

通过这些代码我们可以看到，如果在函数里使用 finally 效果就会很不一样

执行顺序是：

try/except 的正常操作 -> finally 的操作（包括 return，如果这里 return 就直接出去了）-> try/except 的 return

面试题2：

可以看到这段代码没有捕捉到错误，但是却没抛出异常

原因是 finally 中的 return 可以清除保存的异常信息，这个需要注意！

文件操作

了解一些最基本最常用的操作即可

f=open("filename", mode="r", encoding="utf-8") 默认参数是 read 和解码方式 utf-8

注意是解码方式，也就是与文件编码方式对应，有时候不对应也好用是因为兼容

gbk文件里如果没有中文，你拿 utf-8 解码也是可以的，但是一旦有必须 gbk 解码的内容，它就会抛异常，比如在其他语言中，结果就会是中文乱码

你之后想用什么编码的字符串，那你就需要用 str() 再去转码

常用操作类型还有 w 写和 a 追加

for line in f:

print(line.strip())

这样就可以一行一行遍历读入了

需要注意的是，一般我们读入后都直接 strip()

一般不会在这种一行的字符串里最后带个 \n ，没意义，况且还不止 \n

文件的回车和命令行不同，命令行到 \n 就是一行结束，一般的读入都是舍弃\n和空格

文件你按下 enter ，就相当于行末有 \n\r，\r是光标移至下一行行首的标志

文件的单字符读取，在这里很容易出现问题，记住你要读两次单字符才能读走 enter

实际上，准确来讲，\n叫换行，\r叫回车，字面义理解

所以理解一下，如果在最后一行敲一个 enter 是没事的，光标在下一行，但最后一个字符 \r 是在我们原本的最后一行行末，所以没事。

python 的 line.strip() 很棒，这些乱七八糟的空白符都能删掉。

如果你不 strip，你会发现 print 打印后每行下面都有一行空行，这实际上因为 python 的 print 本身就换行啊，是这个原因，不要混乱了。

f.read() 读入全部内容

f.read(num) 读入 num 个字符

f.readline().strip() 读入一行

那么怎么判断 EOF 呢，python 这里真的非常简单

直接 f.readline() == '' 就可以了

读空了就会返回空串，不管读多少次都是这样，不会抛异常，这点真好

f.seek(offset,whence=0) 向后移动 offset 个字节，whence=0表示从开头，=1表示从当前位置，=2从文件末尾，这时候 offset 用负数，这个函数意义不大，毕竟是字节，像 GBK 它中文三字节判断挪多少也是个麻烦事

f.tell() 返回当前字节偏移位置

f.write('xxx') 这个是写，就是把 xxx 写进去

记得养成好习惯，最后写个 f.close()

如果你写东西了，也养成个好习惯，刷新管道，f.close() 之前，写一个 f.flush()

Python3进阶复习：https://blog.csdn.net/weixin_44077863/article/details/117554469

Python3基础复习相关推荐

Python3进阶复习
python3基础复习:Python3基础复习_でこもりさなえ的博客-CSDN博客有好多本来应该算是进阶的内容,因为延伸,顺势就给写进基础复习里了,请一定要去看!!! 基础复习里的内容并不都是那么 ...
Python3机器学习工具包基础复习
Python3进阶复习:Python3进阶复习_でこもりさなえ的博客-CSDN博客机器学习四剑客:numpy.pandas.matplotlib.pyplot.PIL 实际上感觉 sklearn ...
【面试复习】Python基础复习
[面试复习]Python基础复习前言相信一些学习python的朋友找不到一些python的的朋友找不到相对应的python面经,所以博主就推荐大家可以去牛客上面看看哦,各种大厂面经和习题哦! 地址 ...
江苏省专转本计算机教程,江苏省专转本计算机基础复习(含真题)教程.doc
江苏省专转本计算机基础复习要点与历年真题2005年-2014年 2014.10 第一部分复习要点第一讲信息技术---3 第二讲计算机硬件------8 第三讲计算机软件---------- ...
01月26日【Python3 基础知识】
01月26日[Python3 基础知识] 5.1 九宫格 5.2 函数入门 5.3 判断某天为某年的第几天 5.1 九宫格 import random x = 0 l = [1,2,3,4,5,6,7 ...
Python3 基础语法（笔记2）
写在这里的初衷,一是备忘,二是希望得到高人指点,三是希望能遇到志同道合的朋友. 巩固Python,记录关键知识,便于温故知新! 目录 import 与 from...import import 与 f ...
Python3 基础语法（笔记1）
写在这里的初衷,一是备忘,二是希望得到高人指点,三是希望能遇到志同道合的朋友. 巩固Python,记录关键知识,便于温故知新! 目录 1.标识符 2.多行注释 3.行与缩进 4.多行语句 5.字符串( ...
python计算1到100的和-Python3基础 sum,range 计算1到100的和
镇场诗: ---大梦谁觉,水月中建博客.百千磨难,才知世事无常. ---今持佛语,技术无量愿学.愿尽所学,铸一良心博客. --------------------------------------- ...
Java基础复习笔记系列九网络编程
Java基础复习笔记系列之网络编程学习资料参考: 1.http://www.icoolxue.com/ 2. 1.网络编程的基础概念. TCP/IP协议:Socket编程:IP地址. 中国和美国之 ...

Python3基础复习