主要内容：
- 编码和注释
- 用户输入输出
- 字符串，列表，元组，字典，集合的使用
- 函数
一、编码和注释
编码
python编译器对内容默认使用ASCII编码，ASCII主要用于显示英文和其他西欧语言，而UTF-8编码可以用来显示中文。
修改Python编译器的编码，可以在编译器里输入：# _*_ coding:UTF-8 _*_
注释
单行注释： #注释内容
多行注释：'''注释内容'''
二、用户输入输出
输入：input()
输出：print()
三、字符串、列表、元组、字典、集合的使用
字符串
字符串可以使用加号，让两个字符串相连
strings="123456"
strings2="abcdefg"
strings3=strings+strings2
print(strings3) #可以输出：123456abcdefg
字符串中使用转义字符
s="I \'M OK! \n"
字符串以原样输出
s=r"I'M OK! \n"
print(s) #输出： I'M OK! \n
获取字符串的长度 可以使用 len(字符串)
从字符串中获取某个字符，可通过下标索引来获取，当索引为负数时，是指从最后一个字符开始，反方向获取
n="abcdefg"
print(n[0]) #这里获取到的值是:a
f=n[-1] #获取到的值是：g
获取某一个范围内的字符，可通过切片来获取，切片形式 [开始位置：结束位置：间隔长度]
n='abcdefg'
q=n[1:4] #这里可以获取到的值是：b c d
q2=n[1:5:2] #这里可以获取到的值是：b d
q3=n[5:1:-1] #这里可以获取到的值是：f e d c
q4=n[:4] #这里可以获取到的值是：d c b a
q5=n[2:] #这里可以获取到的值是：c d e f g
q6=n[::-1] #这里可以获取到的值是：g f e d c b a
字符串中的一些函数
string3="abcdefg"
#find()字符串是否包含指定字符 是返回开始的索引值 否返回-1
print(string3.find("a"))
#index()字符串是否包含指定字符 是返回开始的索引值 否则提示错误
#count()返回字符在字符串中出现的次数 count("字符",开始，结尾)
print(string3.count(" ",2,))
#replace()替换字符 replace("旧字符","新字符")
print(string3.replace("c","C"))
#split 返回分割后字符串的列表
print(string3.split("e"))
列表
获取列表中的值，也是通过下标索引来，获取方式可参考字符串，获取列表中数值个数，也可以使用 len()方法
aList=['a','b','c','d','e','f']
b=aList[1] #获取到的值是:b
c=aList[1:4] #获取到的值是：b c d
d=aList[1:5:2] #获取到的值是：b d
print("b的值:%s,c的值:%s,d的值:%s"%(b,c,d))
添加数值
aList=[1,2,3,4,5]
aList.append(6) #在列表末尾插入数值
print(aList) #输出的是 [1,2,3,4,5,6]
aList.insert(0,7) #在列表第一个位置插入数值
print(aList) #输出的是：[7,1,2,3,4,5,6]
bList=['a','b','c']
aList.extend(bList) #在列表中追加另一个列表的值
print(aList) #输出的是：[7, 1, 2, 3, 4, 5, 6, 'a', 'b', 'c']
删除数值
aList=[1,2,3,4,5,6,7,8]
del aList[0] #删除数值 1
aList.pop(3) #删除数值 4
aList.remove(6) #删除数值 6
更改数据
dList=[1,1,2,3,4,5]
dList[0]=0 #将第一个数值修改成 0
print(dList) #输出的是：[0,1,2,3,4,5]
元组
元组表示方式：sTuple=(1,2,3,4,5)，当元组中只有一个数值时，表示方式：sTuple=(1,)
元组是不可变列表，只可以删除元组和获取值，但不可以对数值进行修改，追加
sTuple=(1,2,3,4,5)
s=sTuple[0] #通过索引获取数值
print(s)
del sTuple #删除元组
字典
字典表达方式：sDict={'a':1,'b':2,'c':3}
sDict={'a':1,'b':2,'c':3}
#通过键获取数值
s=sDict['a'] #获取到的值是：1
#添加数值
sDict['d']=4
print(sDict) #输出{'a':1,'b':2,'c':3,'d':4}
#更改数值
sDict['a']=0
#删除数值
del sDict['a']
sDict.pop('a') #删除指定键值
print（sDict） #输出：{'b':2,'c':3,'d':4}
字典函数
sDict={'a':1,'b':2,'c':3}
#获取字典长度
l=len(sDict)
#获取字典中的键
k=sDict.keys() #得到的值是：dict_keys(['a','b','c'])
#获取字典中的值
v=sDict.values() #得到的值是：dict_values([1,2,3])
#获取某个键的值
m=sDict.get('a') #获取a键的值 1
#将字典列表化
dictList=sDict.items() #得到的值是：dict_items([('a',1),('b',2),('c',3)])
集合
集合的表达方式：{'a','b','c','d','e'}，如果是空的集合，表达方式：set()。集合是无序，不重复的，它会自动去掉重复的。
添加数值，有两种方式：add和update
st={'a','b','c','d','e'}
st.add('f') #通过add方法添加
st.update([1,2],[3,4]) #通过update方法添加多个值
print(st) #输出的是：{1, 2, 'd', 3, 4, 'c', 'e', 'a', 'f', 'b'}
删除数值
st={'a','b','c','d','e'}
st.remove('a') #删除指定值
st.pop() #这里的pop方法跟列表中的pop方法是有区别的，这是因为集合是无序的，无法确定位置，这里是抛出最后一个字符
print(st)
st.clear() #清空集合数值
print(st) #输出的是：set()
集合之间的交集，并集，差集，对称差集
a={1,2,3,4,5}
b={2,4,6,8,10}
#交集 （在a中也在b中）
intsec=set.intersection(a,b)
print(intsec)
#或者
otherIntsec=a&b
print(otherIntsec)
#并集
unionSet=set.union(a,b)
print(unionSet)
#或者
unionOther=a|b
print(unionOther)
#差集（值在a中，且不在b中）
bset=set.difference(a,b)
print(bset)
#或者
bsetOther=a-b
print(bsetOther)
#对称差集(在a或b中，不同时出现在两者中)
aset=a^b
print(aset)
四、函数
函数使用 def 关键字定义：def 函数名（参数，*args，**kwargs），参数*args和**kwargs是非固定参数，*args会将传入的参数变成一个元组形势，**kwargs会变成一个字典形式。
def test():
print('无参数函数')
def test1(n):
print('有参数n:{0}的函数'.format(n))
def test2(*args):
print('有参数args:{0}的函数'.format(args))
def test3(**kwargs):
print('有参数kwargs:{0}的函数'.format(kwargs))
#调用方式
test() #输出 无参数函数
test1(1) #输出 有参数n:1的函数
test2('args1','args2') #输出 有参数args:('args1', 'args2')的函数
test3(key1='value1',key2='value2') #输出 有参数kwargs:{'key1': 'value1', 'key2': 'value2'}的函数
递归函数，就是函数内部调用自己。递归每一次都是基于上一次进行下一次的执行，但需要界定一个结束递归条件。
def Jchen(n):
if n==1:
return 1
else:
return n*Jchen(n-1)
print(Jchen(5)) #输出5！的值：120
'''
第一次：Jchen(5)=5*Jchen(5-1)
第二次：Jchen(4)=4*Jchen(4-1)
第三次：Jchen(3)=3*Jchen(3-1)
第四次：Jchen(2)=2*Jchen(2-1)
第五次：Jchen(1)=1 最后判断终止递归的条件
也就是：5*4*3*2*1
'''
匿名函数，没有具体的函数名称，不必担心函数名冲突，也可以匿名函数赋值给变量，再利用变量来调用。
格式：lambda 参数[,参数2[,：表达式（只能有一个表达式，它相当于return）
def n(x):
return x**x
print(n(2))
#匿名函数表达
fx=lanbda x:x**x
print(fx(2))
高阶函数，即一个函数可以接受另一个函数作为参数。
def add(x,y,f):
return f(x)+f(y)
print(add(-2,3,abs)) #将函数名作为变量输出时，其结果是函数本身
- map高阶函数
- reduce高阶函数
- filter高阶函数
- sorted高阶函数
map高阶函数，接收两个参数，一个是函数，一个是Iterator。它是将函数作用在每个序列元素上，最后返回一个新的Iterator。由于Iterator是惰性序列，因此通过list()函数返回list。
def n(x):
return x**x
m=[1,2,3,4]
mapList=list(map(n,m))
print(mapList) #输出的是：[1,4,27,256]
#使用匿名函数
mplist=list(map(lambda x:x**x,m))
print(mplist)
reduce高阶函数，是对序列元素做累积计算。
from functools import reduce #引入reduce
'''
reduce(表达式,序列,初始值)，以下列例子说明:
当没有初始值时，其计算方式((((1+2)+3)+4)+5)
当有初始值时,其计算方式是将初始值作为第一个数，进行同样的计算
'''
listF=[1,2,3,4,5]
new_reduce=reduce(lambda x,y:x+y,listF,0)
print(new_reduce) #输出15
filter高阶函数，用于过滤序列元素
lists=[1,2,3,4,5,6,7,8]
nlists=list(filter(lambda x:x%2==0,lists))
print(nlists) #输出：[2,4,6,8]
sorted高阶函数，用于序列的排序
dicts={"a":1,"c":2,"b":3}
dicts=sorted(dicts.items(),key=lambda x :x[1],reverse=True) #reverse为True，降序排列，反之，升序排列
print(dicts) #输出：[('b',3),('c',2),('a',1)]
偏函数，把一个函数的某些参数设置默认值，返回一个新的函数
import functools
int2 = functools.partial(int, base=2) #将int中的base参数默认为2进制
print('1000000 =', int2('1000000')) #输出：64 将字符串转换成2进制
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
