1.字符串
>字符串大小写,都不会修改原来的值
message = 'your name'
message.title() # Your Name
message.upper() # YOUR NAME
print(message.lower()) # your name
>python 整除向小的取
9/4 = 2.25 ,9//4 = 2
-9/4 = -2.25 , -9//4 = -3 ;注意不是-2
>split() 默认是空格，无论几个空格连着都算一次
x = " a boy "
y = x.split() # y = ['a','boy']
不是特别不要在split()中加上‘ ’
>字符串格式化
temp1 = 'Xiao'
temp2 = 'Ming'
# f""用于格式化，{}表示替换,python3.6后引入
temp3 = f"{temp1} {temp2}" # Xiao Ming
temp2 = f"{x:.2f}" #将x保留2位小数
print("123",end=" ") # print函数不换行
# python3.5以前的用法, " ".format()
temp4 = "{} {}".format(temp1,temp2)
>字符串删除空白,删除两头，左边，右边
message = ' shcool '
message.strip() # 'school'
message.lstrip() # 'school '
message.rstrip() # ' school'
>字符串替换空格
x = "abc def"
x.replace(" ","") # "abcdef"
x = "@sg$$"
x = x.replace(x[0]," ") #" sg$$"
>字符串直接转列表,加list
x = "abc"
y =list(x) # ['a','b','c']
>字符串右对齐，把已有的数据靠右，在左边补齐,同理ljust()
str.rjust(对齐长度，填充字符),不加填充字符默认为空格
x = '123'
x.rjust(5,'0') # '00123'
x.rjust(5) # ' 123'
>将字符串序列按指定格式转换为字符串 .join(),像x = [1,2,3]数字序列不可以
x = ['a','b','c']
y = ''.join(x) # abc
z = '-'.join(x) #a-b-c
w = ' '.join(x) #a b c
print(' '.join(x)) #a b c
>[起始:终点:间隔] #列表相同取法
x = '123456'
x[-1] = 6
x[0] = 1
x[0:-2] = '1234' #遵循左闭右开
x[0:] = x[0:len(x)] = '123456'
# 取倒序
x[::-1] = '654321' 表从0开始，每次往后取
x[::2] = '135' #也是偶数下标的值，从0开始，每次间隔2
x[1::2] = '246' #是奇数下标的值，从1开始，每次间隔2
>range(start,stop,step) 起点，终点，步子
和上面的都是最后一个是步子
>字符串原地，奇数位 偶数位排序
x = "dcafbd" #字符串本身不可变
x = list(x) #列表可变
x[::2] = sorted(x[::2]) #右边产生一个新的序列，被赋值到左边的x，sorted()不改变x本身
x[1::2] = sorted(x[1::2]) #奇数位排序
>int(x,base) base默认是10进制，可选2,8，16
s = int("123") # 123
s = int("2.3") # error
s = int("23ab",16) #从16进制转为10进制
>输入一串"12 23 45" 转换为列表，元素是int类型
x = [int(i) for i in input().split()] #split()默认按" "分割
print(x) # [12,23,45]
>chr(x) ascii转化为字符
>ord(x) 将字符转换为对应ascii码,
x = ['a','f']
y = chr(ord(x[0]) + 1) # y = 'b'
>>>>>>>使用进制转换函数，得到的字符串前两位要舍去<<<<<<<<<<<<<
x = 4
y = bin(x) # y = '0b100'
y = bin(x)[2:] # y= '100'
然后使用.rjust(,'0') 来对字符串填充
>注意 bin()和hex()都是作用与10进制，要先用int('',进制)将字符串转为10进制，再用这俩函数。
>oct() 表示 8进制
>hex() 10进制转16进制,把10进制整数转为16进制,得到的是字符串
x = 10
print(hex(x)) #'0xa' a代表10
>bin() 10进制转2进制,把10进制整数转为2进制
x = 4
print(bin(x)) '0b100' 0b是2进制,
print(bin(x)[2:] '100' 去掉前面的0b
print(bin(x)[2:].rjust(4,'0') #将'100' 右对齐，左侧补上0 ，'0100'
print(bin(x)[2:].rjust(4,'0')[::-1] # 将'0100'倒叙 ,'0010'
>字符串直接转列表
x = "123"
y =list(x) # y = ['1','2','3']
>对输入的EOF判断
1. sys
import sys
for line in sys.stdin: #直到所有行都输入完毕
a = line.split() #line相当于input()读取的一行
2. try except
try:
while True:
s = input()
except EOFError:
pass
>字符串查找子串函数 find()未找到返回-1,找到则是索引
st = "abcdff"
x = "ee"
y ="cd"
st.find(x) # -1
st.find(y) # 2
>sorted(iterable,key=,reverse=) #对可迭代对象，字符串、列表、元组、集合、字典进行排序
# 返回的是列表,key=后接的是函数名称，如len默认长度、str.lower、按小写，也可以自定义
st = "AknbcDB"
x = sorted(st,key=str.upper) #指定字符串类型的大写排序
# x = ['A','b','B',...]
#自定义函数
def su(x):
return x[-1] #返回最后一位
x = ['abz','ADa','FDb']
y = sorted(x,key=su) #按每个字符串最后一位来比较排序，如果启用reverse可以逆序
# y =['ADa', 'FDb', 'abz']
>字符串去重
x = "agsxcaabd"
1.set() 会变得无序
y = set(x) # {'g','a','s','b','d','c'}
2.遍历逐个添加
y = []
for i in x:
if not i in x:
y.append(i)
>列表排序
list.sort(key=) # 默认小的在前，大的在后,并且返回1表示真，-1才表示假
python2 是sort(cmp=func)
python3 是sort(key=functools.cmp_to_key(func))
import functools
python3 中 key = functools.cmp_to_key(lambda x,y : 1 if (x+y)>(y+x) else -1)
x = [1,23,32]
num = list(map(str,x)) #['1','23','32'] #把数字list转为str的list
num.sort(key = functools.cmp_to_key())
2.列表
>list 用方括号[],有序，可以索引从0开始, -1表示最后一个元素，-2表示倒数第二个
house = ['Beijing','Shanghai']
>修改列表元素
house[0] = 'China'
>append() 末尾添加
house.append('Guangzhou') # 'China','Shanghai','Guangzhou'
>insert(index,value) 任意位置插入元素
house.insert(1,'Tianjin')# 'China','Tianjin','Shanghai','Guangzhou'
>del 删除列表元素，按其索引
del house[0] # 'Tianjin','Shanghai','Guangzhou'
>pop(index) 弹出列表末尾元素，不指定默认末尾
result = house.pop() # 'Tianjin','Shanghai'
>remove(value) 弹出指定值元素,多个相同删除第一个
house.remove('Tianjin') # 'Shanghai'
>sort() 直接改变列表本身
house.sort()
# house.sort(reverse = True) 逆序排列
>sorted() 临时返回一个被排序的列表，本身不变
print(sorted(house))
>reverse() 将本身列表逆序
house.reverse()
>len() 确定长度
len(house)
>列表判空的三种方式
if len(x) == 0:
if x is None:
if x == []
>遍历列表,在in的右侧是一个列表，不断为左侧的i赋值
for i in house:
print(i) #输出列表元素
>创建数值列表
for i in range(1,100):
print(i) # i从1到99
number = list(range(1,10)) # 将range创建的数值转化成列表
number1 = list(range(1,10,2)) #以2为步长创建 1,3,5,7,9
>统计计算
house = [1,2,3,4,5,6,7,8]
print(min(house)) # 1
print(max(house)) # 8
print(sum(house)) # 36
x = 2
print(x*2) #4
print(x**3) #幂运算x^3=8
print(f"{x:.2f}") #输出带2位小数 2.00
>and or not 与 或 非
print(x and y)
print(x or y)
print(not x)
>数字按位与或 & |
x = 10
y = 12
print(x & y) # 相与
print(x | y) #按位或运算
>列表解析
house = [value**2 for i in rang(1,11)] #返回一个列表
其中value是临时元素，for循环用来为value不断赋值，左右的方括号是列表的意思
x = [i for i in range(1,51) if i%5==0 ] #满足后面表达式的i会被返回
x = [i if i%5==0 else 200 for i in range(1,51)] #不满足条件的返回200
>访问列表的一部分，也就是切片[:] 冒号两侧指定索引开始和结尾
house = ['a','b','c','123',56]
print(house[1:3]) # b c
print(house[-3:]) # c 123 56 从倒数第三元素到结尾
>列表的复制,完全新的副本，与只是索引
house = [1,2,3,4,5,6]
newHouse = house[:] # 完全新的副本,与house不在一篇存储空间
indexHouse = house # 只是索引，同一个存储地址
>创建二维数组的问题
w1 = [[0]*100]*100 #这是一个100*100的数组，修改w1[0][1]=1 会把w1[:][1]全部改为1
w2 = []
for i in range(100):
temp = [0]*100
w2.append(temp) #修改w2[0][1]就不会和w1的现象
w3 = [[[0] for i in range(100)] for j in range(100)] #修改w3[0][1]也不会和w1现象一样
3.元组
>元组是不可以改变元素，使用的圆括号，而非方括号 ()
house = (1,2,3,4,5)
# house[0] = 10 会报错，不能修改元组
>定义只有一个元素的元要加逗号,但是自动生成的元组可以只有一个元素
house = (1,)
house = (1) # 这时house是一个int型变量，而不是元组，两侧变成运算符合
>可以给元组重新赋值，并不会报错
house = (11,2)
house = (22,3)
>tuple() 将List转元组
x = [1,2,3]
y = tuple(x) # (1,2,3)
> 连接两个元组
x = (1,2)
y = (3,4)
z = x + y # (1,2,3,4)
>集合,是花括号
a = [1,2,3,2]
b = set(a)
print(b) #{1,2,3} 去重的集合，是花括号
c = list(b) # c = [1,2,3] #此时是列表
4.if语句
>判断
== 相等
!= 不相等
and 且，两边都要真为真
or 或，只要一个真就真
if i in house : 检查在列表中 in
if i not in house : 检查不在列表中 not in
>if-else
if i == 10:
print('ok')
else:
print('not ok')
>if-elif-else 检查多个情况，但只遇到合适的执行一次，就停止剩下的检测
if age < 2:
print('小于2')
elif age < 4:
print('大于等于2，小于4')
elif age <8:
print()
else:
print('大于等于8')
#省略else
#elif age >= 8:
# print('大于等于8')
5.字典与集合
>字典是用一对{key:value,}来表示，和列表、元组不同,访问还是用[key]其中仍然是方括号
>key是唯一的
house = {'China':1,0:1,'Beijing':2}
>del 用来删除指定key,和列表的删除一样
del house['China'] # 删除这个k-v对
>get(key,replace) 进行查找key对应的value,不存在返回replace，不指定返回None
print(house.get('China','not include')) #打印出not include
>items() 字典的每一个Pair称作item,遍历item按照,python3.6后按添加顺序遍历
for k, v in house.items():
print(k,v) # Beijing 2
>keys() 返回所有的键为一个列表
for k in house.keys():
>values() 返回所有的值为一个列表
for v in house.values():
set(house.values()) #通过集合为返回的列表去重,在存在大量重复的value时很有效
>集合set()
>集合是只有键，没有对应值，也是用{}创建
house = {1,2,3,4,'aa'} #元素不能重复
>列表的元素可以是字典
>字典的value可以是列表
house = {"china":1,1:2}
list = [house]
list[0][1] = 3 #修改house的key为1的value
house = {"china":[1,2,3],5:2}
>zip()函数 和dict()
x = [1,2,3]
y = [4,5,6]
di = zip(x,y) # 返回元组，((1,4),(2,5),(3,6))
f = dict(di) # 转换成字典
6.input和while
>input('提示语) 终端输入赋值
w = input('please') #输入的字符串赋值给w
>int(str)将str强转为整形
str = input('please input number\n')
a = int(str) #a为一个整数
>while循环
number = 0
while number < 10 :
number += 1
continue #跳过执行
break #终止
house = ['dd','dd','aa']
while 'dd' in house: #判断一个元素是否在列表中
house.remove('dd') #一次只移除第一个找到的元素
7.函数
>函数格式，参数、返回值都是可选，可以返回多个值
def funname():
pass
>传递列表到函数中，则传递的是引用，而不是拷贝
funname(house) #这是拷贝
funname(house[:]) #这是副本
>接收任意长的参数 *
def fun1(*para):
# *将para接收的所有参数打包成一个元组
for i in para:
print(i) #注意是遍历para而不是 *para
>指定参数+任意参数；指定参数要放在前面
def fun2(age,name,*para):
# age和name是两个参数，para是一个元组
pass
>** 表示一个空字典
def fun3(age, name, **para):
para['age'] = age
para['name'] = name
return para
paranew = fun3(10,20,'a':2, 'b':3) #从第三个参数开始要传递的是键值对
print(paranew) #{'a':2, 'b':3, 'age':10, 'name':20}
>import 将独立文件中函数导入到当前文件
#a.py
def func1():
pass
#b.py
import a
print(a.func1()) #调用模块a的函数
>from xx import func1 从模块xx中只导入函数func1
并且调用时直接用func1() 不需要加入xx.
> import numpy as np 其中的as用来给numpy起别名
>map(func,*itreables) 将func函数映射到迭代的每个元素上,返回的是句柄
print(list(map(len,['abc','12345'])) # [3,5] 最终得到的是列表
>reduce(func,seq[,init]) 将func函数每次从seq中取出两个元素作用，做累计
from functools import reduce
print(reduce(add,range(1,10)) # 45 = ((1+2)+3)...
>filter(func,*itreable) 将func作用于序列，起到过滤作用，不符合的去除,func为None表示空,
返回的是句柄
print(list(func(str.isdigit,['abc','123','45','']))) # ['123','45'] 过滤了非数字
>lambda [参数列表]:表达式 #相当于匿名函数
func = lambda x,y: x+y
print(func(3,4)) # 7
>yield 生成器函数，返回生成器对象，先生成数据，然后暂停执行，索要时再恢复执行
>等比公式
an = a1 * q^(n-1) Sn = (a1 * (a-q^n))//(1-q)
8.类
>基本结构
class Car:
def __init__(self,name,age):
self.name = name
self.age = age
def Speak(self):
print(f"{self.name}<< >>{self.age}")
>继承
class EletricCar(Car): #这时创建类要加()来传入父类
def __init__(self,name,age):
#初始化父类的init函数
super().__init__(self,name,age)
self.battery = 20 #子类独有的属性
def Speak():
# 可重写父类的方法
pass
def Speak1():
# 在当前函数调用Speak要加self,否则会未定义
self.Speak()
pass #子类独有的方法
ele = EletricCar("BEn",12)
ele.Speak()
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
