python学习-基本语法元素

1 数据类型

1.1 数字类型

整数int，实数float，复数类型complex
整数：
16==0b10000=0o20==ox10
以上4者输入时等价，分别代表十，二，八，十六进制
进制转换函数：

a=bin(16)#2
b=oct(16)#8
c=hex(16)#16

由于转化后变为字符串类型，所以不相等

x=int(2/8/16进制的数，2/8/16)#其余进制转10进制

浮点数：
由于在计算机里储存的方式，所以会出现(0.2+0.1)!=0.3的情况，不过误差小，不影响计算。这个问题可以通过下面的方式解决：

b=round(a,1)#对a保留一位小数

复数：
complex:
a+bj的形式

a=5+5j
a=5+1J#大写也行，虚部系数为1不能省略

运算操作符：
a**b求a的b次方
a//b求整数商，向下取整
整数于浮点数计算结果为浮点数，出发运算的结果为浮点数
运算操作函数：

abs()#求绝对值，复数就是求复数的模  
pow(a,b,c)#求a的b次同时对c取摸（快速幂的都懂），没有参数c时等价于a**b
round(a,b)#对a保留b位小数，b没有默认保留整数，b过大不补多余的0   
divmod(x,y)#返回一个二元组(x//y,x%y)  
min(d1,d2,d3,d3,...)#求序列最小值，参数可以是组合类型的变量
max(d1,d2,d3,d4,...)#求序列最大值，参数同上
sum([d1,d2,d3,d4,...])#求和，不能去中括号，或者加小括号表示元组也行

其余的一些科学运算的函数需要导入库

1.2 字符串类型

表达：''或""

• 字符串里存在双引号，外面就用单引号括起来；
• 如果里面存在单引号，外面就用双引号括起来；
• 如果里面同时存在单引号和双引号，那就对里面的引号前添加转义字符''
• 转义字符可以表示连接写成两行的字符串如：

a="I LOVE \
FLOWYUAN"#和上一行的内容连接
print(a)

访问：
和数组一样下表索引，不过可以通过负数倒序索引，如：-1是最后一个元素，-2是倒数第二个元素...
取子串：
变量名[开始位置:结束位置:切片间隔]

s=[Flowyuan]
a=s[0:4:2]#从0开始没隔1个字符取一个字符加入子串a中
#取的区间范围[0,4)这个取的就是F,o，即Fo。
#但是[0,4)左闭右开，所以不包括y。
#如果不写2就默认1，就是取相邻的字符。
#开始位置不写默认0
#结束位置不写就是默认可以取全部
a=s[-5:-1:-1]
#也可以取负数哈，前两个参数省略类比可知，但最后一个参数绝对不能省略啊

运算

• 用'+'拼接两个字符串
• 用''使字符串重复加倍，如'ab'3=='ababab'

判断是否为子串（连续切片）

"Hello" in "Hello world"#值为true，倒过来的切片不清楚

遍历：

for s in "yahaha":
  print(s)

字符串处理函数

#--------------------------------------------#
s="ya ha ha"
len(s)#取s长度
s_list=s.split(' ')#以空格为分割字符分隔s，返回序列['ya','ha','ha']
#--------------------------------------------#
s="ya ha ha"
s_jion=",".join(s)#聚合字符，把','插入到s的每个字符之间，返回"y,a, ,h,a, ,h,a"
s=['1','2','3']
s_jion="*".join(s)#对象也可以是元素为字符类型的序列,每个元素必须为字符类型，返回"1*2*3"
#--------------------------------------------#
s="     yahaha     "
s.strip(" ")#从两端搜索去除两端的空格字符，遇到非指定字符时停止搜索
s.lstrip(" ")#同上，不过只删左边
s.rstrip(" ")#同上，只删右边
#--------------------------------------------#
s="yahaha"
s=s.replace("ha","hahaha")#把所有"ha"替换成"hahaha"
s="abababababa"
s.count("aba")#"aba"出现的次数,读过的abc里面任何字符的不计入下一次搜索"aba"，也就是说返回3而不是5
s.count("a")#同上
#--------------------------------------------#
s=s.lower()#全字母小写
s=s.upper()#全字母大写
s=s.title()#首字母大写
#--------------------------------------------#

字符编码：
和C++用的ASCII码不同，python用的是Unicode编码
用ord函数进行转换

ord('1')==49
ord('a')==97
ord('*')==42
ord('中')==20013
#感觉和ASCII码差差不多
#不过尝试了一下不能直接把字符当作数字与整数相加了，爷青不回。感觉hash起来可能就会有点麻烦
#----------数字换字符----------#
chr[49]='1'
chr[97]=='a'
#类推

1.3 布尔类型

一些函数

any([1,0,true])#只要序列内存在1就返回1，相当于或
all([1,2,true])#只要序列内存在0就返回0，相当于与
#不过中括号内不能进行运算，python里面不能||或者&&,不过二进制运算符|,&,>>还是可以用的

作为掩码，不过个人不懂，以后解决

1.4 类型判别和类型转换

type(a)#返回a的变量类型,如果是int就返回：<class 'int'>
isinstance(a,类型C)#判断a是否会类型C或者说是类C的一个实例或者说有继承关系的实例
#-------------------------------#
str(a)#数字到字符
int(a)/eval(a)/float(a)#字符到数字，eval是int和float的整合

1.5 组合类型

列表：

• list
• 序列类型
• 表达方式：[d1,d2,d3,d4,...]
• 访问和数组一致

列表的表达 ：

lis=["abc",12,12.9,True,...]#对内部元素包容性强，也可以列表套列表，套元组套字典等等

直接产生列表，list函数
格式list(可迭代对象)，可迭代对象包括字符串,元组，集合等

list("传统美德")#字符串产生产生列表['传','统','美','德']
list(('传','统','美','德'))#元组产生列表['传','统','美','德']
list({'我','带','你们','打'})#集合尝试列表（乱序的）['我','带','你们','打']，由于集合内部无序，我带你们打几个字的顺序会打乱

特殊的range()函数
格式range(起始数字a，终止数字b，字符间隔c)

for i in range(6)#这里i从0循环到六，a默认0，c默认1。区间同样是左闭右开

个人测试把range()函数放入type函数中输出结果为<class 'range'>，说明range是一个单独的组合数据类型，这也意味着它也可以放入list函数中产生一个列表,例如:

list(range(1,11,2))
#产生列表[1,3,5,7,9]

列表的性质

• 下标访问，和字符串一致，也可以为负数
• 切片lis[a:b:c],用法和字符串一致
• len(lis)取长度，即元素个数

操作符：

• a+b 拼接，a尾和b首相连
• [0]*10，产生列表[0,0,0,0,0,0,0,0,0,0]

操作方法：

#----------------插入-------------------#
lis.append("yahaha")#在列表lis尾部添加元素"yahaha"，如果小括号内为一个列表，则把列表作为一个元素插入尾部
lis.insert(1,"yahaha")#在下标为1的元素前插入元素yahaha，其他下标位置同理
lis.extend([1,2,3])#在列表尾部逐个加入括号内列表元素
#----------------删除-------------------#
lis.pop(i)#把下表为i位置的元素删除，不填默认最后一个
lis.remove(1)#删除列表内第一个为1的元素
while 1 in lis:
  lis.remove(1)#用循环把1删除干净
#----------------查找-------------------#
lis.index("yahaha")#查找lis中元素"yahaha"的位置，如果存在返回下标，不存在报错
#修改元素略
#----------------复制-------------------#
arr=lis.copy()#浅拷贝，直接'='是起别名
arr=lis[:]#同上
#----------------排序-------------------#
lis.sort()#升序
lis.sort(reverse=1)#降序
arr=sorted(lis)#临时升序排序并赋给arr，lis内部顺序不变
arr=sorted(lis,reverse=1)#同上，降序
#----------------其它-------------------#
lis.reverse()#翻转
for i in is:
    print(i)#遍历

元组：

• tuple

• 序列类型

• 表达方式：(d1,d2,d3,d4,...)

• 不支持元素增加，元素删除，元素修改的操作，其余操作均与列表一致

一些作用：
打包与解包：

#函数返回时打包：
return x**2,x**3#返回二元组(x**2,x**3)，x是输入的量
#解包：
a,b=(x,y)#实现解包赋值，去掉括号或者直接一个元组类型的量也行
#zip打包：
nums=["1","2","3"]
names=["熊天使","德克萨斯","拉普兰德"]
list(zip(num,name))
#获得列表[(1,"能天使"),(2,"德克萨斯"),(3,"拉普兰德")]
#zip解包遍历
for num,name in zip(nums,names):#zip也是个个类型，可以用type输出试试。这里不填zap用刚刚产生的list也行
    print(num,name)

字典：

• dict
• 映射类型，和map类似，内部无序，可能访问O(logn)？
• 表达方式
• 例如stu={123:"ff0",123:"铃兰"}，可以通过stu[123]访问铃兰

dict的要求：

• 字典的key不能重复，重复了后面录入的value覆盖前一个的value。
• key必须是不可变类型，如数字，字符串，元组。不可以是列表字典集合。

dict的性质

• len()取键值对的个数
• 索引，用key找value

dict操作

#------------增删-------------#
stu["001"]="asvda"#增加键值对
del stu["001"]#删除key值为"001"的一对
val=stu.pop("001")#同上删除，不过会把对应的"asvda"作为返回值给val
tup=stu.popitem()#随机删除一个键值对，并以元组返回删除的键值对
#修改略
#------------查找-------------#
stu.get(key,default)#如果key存在，返回stu[key],如果不存在，返回value,以后只能靠这个计数了==
#----------其它方法-----------#
print(dic.keys(),' ',dic.values())#输出dic.keys(所有键值组成列表) dic.values(所有value组成的列表)。个人用type试了试类型，，，结果这又是一种新类型！？以后这种不管好了，顾忌太多对心脏不好
list(dic.keys())#产生所有key组成的列表
list(dic.values())#产生所有value组成的列表
list(dic.items())#产生所有键值对组成的列表，列表的每个元素为包含一个键值对的二元组，这样就可以用for遍历了

集合：

• set
• 和SLT里的set类似，不过虽然互斥但无序
• 表达方式

操作：

#设两有个集合se1,se2
se1 & se2#取交集，返回一个集合
se1 ^ se2#返回一个新集合，包含se1和se2中非共同元素，即se1有se2没有，和，se2有se1没有。
se1 - se2#返回一个集合，包含在集合se1但不在集合se2中的元素
se1 | se2#求并集
#-----------------------#
se.add(元素)#添加
se.remove(元素)#删除
for i in se:
  print(i)#遍历

2 变量

• 同C++，不过可以以汉字名为变量名
• 打包赋值： x,y=1,2//把1，2分别赋值给x,y
• 变量互换： x,y=y,x

3 控制流程

3.0一些运算

逻辑运算

not(a>b)#非
(a>b)and(a>c)#与
(a>b)or(a>c)#或
#优先级 非>与>或。个人测试括号里不能对值进行操作。‘假’就是0，值为‘真’也不会把相应的数据类型自动转换为bool型，至于‘真’的值到底是选参与逻辑运算的哪个数 就先不管它了。

存在运算

print("ABC" in a)#a一般为组合类型的数。存在输出1，不存在输出0
print("ABC" not in a)#与上面相反

3.1顺序流程

3.2循环流程

• for 元素 in 可迭代对象。如：

#求和
res=0
for i in [1,2,3,4,5]:
    res +=i
//从1取到5

for v,u in dic:
   xxxx
#从字典中取，上面说了。

• while 判断条件:（条件真进行）。如：

i=1
res=0
while i<=5:
    res+=i
    i+=1
else:#和while搭配使用，当while后面条件不满足时进入。


break#略
continue#略

3.3 分支流程

if xxxx:
elif xxxx:
elif xxxx:
elif xxxx:
else :
//从略

4 输入输出

4.1 输入

• x=input("提示内容")，input获得的是字符串，字符串变量可以和string一样加减比较
• x=eval(input("提示内容")),在外面加上eval可以转换为数字

4.2 输出

• print() 可以打印字符串数字变量等等，并自动换行
• print(x,end="doge")，输出x并以doge为结尾，不换行
• print(x,y,z)，组合输出

格式化输出： "asdas{2}sadas{0}sad{1}asdsa".format(x,y,z)

• x对应0，y对应1，z对应2，其余地方任意填充字符。大括号内全不填默认位置输出，填相同的数字就对应输出对应位置的变量。
• 格式顺序在以下内容叙述完毕给出

填充输出：
print("{0:填充字符+位置符+宽度}".format(x))

print("{0:*^5}".format(x))//x在中间位置，两边填充'*'至宽度为5
print("{0:_<5}".format(x))//x在左边，往x右边填充_至宽度为5
print("{0: >10}".format(x))//同上，往x左边填充' '至宽度为10

输出数字千分位分隔符：

print("{0:,}".format(1000000));//输出1,000,000
print("{0:*^20,}".format(1000000))//输出千分位分隔符同时向两边填充*至宽度20

整数进制转换：

print("{0:类型}".format(x))//转换符号：二进制b，Unicode码c，十进制d，八进制o，十六进制x/X

浮点数简化输出：

print("{0:.2f}".format(x))//保留两位小数，改变2可以调整至保留小数的位数，f表示以浮点数输出
print("{0:.2%}".format(x))//保留两位小数，%表示以百分数形式输出，注意是先转化为百分数再保留小数
print("{0:.2e}".format(x))//以科学计数法输出，先科学计数再保留小数

• 格式顺序

:	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符号	填充字符	<左对齐 >右对齐 ^居中对齐		适用于整数和浮点数	浮点数为控制小数位数 字符串是最大输出长度	整数类型：b,c,d,o,x,X 浮点数类型：e,E,f,%

5 程序格式

5.1 行最大长度79
5.2 缩进表示表示语句间从属关系，缩进量为4
5.3 使用空格：（只是约定成俗）

• 二元运算符两边要加空格
• 不同优先级在最低级运算符两边加空格
• 逗号后加空格
• 不要使用两个以上的空格

5.4 注释

#单行注释
"""
这个是多行注释
"""