Sugarbeet
文章
40
分类
3
评论
1

Python基础

| 学习 •
字数总计 42054 | 阅读时长 105分钟 | 阅读量 373

python中 while if else elif 后都到加 :

python3中只有int

range(0,100,1)0表示起始位置，100表示结束位置，1为每次加1

range(100,0,-1)递减

python是解释性语言

python字符串

  1. 转换成大写 .upper()

  2. 转换成小写.lower()

  3. 判断字符串是否是数字.isdigit()得到的是布尔类型

  4. 去除右边的空白.rstrip()，去除左边的空白.lstrip()，去除两边的空白 .strip()

  5. 替换 .replace(‘敏感词’,‘替换后的词’,数字) 从左至右找到一个替换掉（例：数字是2则替换前两个后面的不变），后面的不变

  6. 切割，切割后是列表形式，.split(',',1) 根据逗号切割，从左至右找到第1个切割，如果要从右往左则需要用 .rsplit(',',1) ，注意如果句子用的是中文的输入法，则逗号也是中文的

  7. 查看字符串是否以"al"开头或结尾，使用 .startswith('al') ，.endswith('al')

  8. format，·name = "我叫{0},今年{1}岁".format('gxw','12')

  9. encode，name.encode('utf-8')将name转换成utf-8编码，一个汉字用unicode编码占4字节，用utf-8占3字节，gbk占2字节

  10. join， 循环每个元素，并在每个元素之间加入连接符 join后面可以循环，字符串，列表，元组

name="alex"  
​  
result="_".join(name) 在alex每个元素之间添加_
  1. 判断字符串是否有敏感词
v = '我是谁'  
if '我' in v :  
 print('含有敏感词')

公共

  1. len()，计算长度，（字符串–计算字符串中字符的个数）

  2. 索引，取出字符串中某一个字符，例：取出第一个字符， value=‘abc’ value[0]，当使用value[-1] 则表示 从后往前取，去最后一个

  3. 切片，取出（子序列）value = “abcd” ，v1 = value[1:2] ，v1 = “b” // 1=< 索引位置 < 2 ，前取后不取，value[1:]，从第二个取到最后包括第二个，value[:2]，取第三个之前的不包括第三个

  4. 删除（数字/布尔/字符串除外），del仅仅是删除，可以删除一个范围[n:m]前取后不取

    del users[1]
-------------
users.pop[1] #列表删除特

    字符串本身不能修改删除//不可变类型。
    不能用del删除字符串。

  5. 修改（数字/布尔/字符串除外）

    users=['a','b',99]
users[2] = 66 #可以修改
users[0] = 'a' #可以修改
users[0][0] #不能修改

  6. 步长，默认步长为1，当步长为负数时从后往前取

    name='alexalex'
val=name[0:-1:2] # 0为起始位置，-1结束位置，2为步长
print(name)
aeae
-------------------
val=name[::2] #从前到后步长为2
-------------------
val=name[-1:0:-2] #从后往前取，步长为2，答案是xlxl
val=name[::-2] #从后往前取，步长为2，答案是xlxl
-------------------
val=name[::-1] #反转，输入xela

  7. for循环

    name='alex'
for item in name : #遍历name将每个字符传递给item并打印
    print(item)

    打印1到10

    for i in range(1,11):  #前取后不取
	print(i)

    打印1到10不打印7

    for i in rang(1,11):  
	if i==7:
		continue
	print(i)

列表

  1. len

    users=["a","b","c"]
val=len(users)
print(val) #3

  2. 索引

    users=["a","b","c"]
val = users[0]
print(val) #a

  3. 切片

    users=["a","b","c"]
val = users[0:2] #['a', 'b']

  4. 步长

    users=["a","b","c"]
val = users[0:2:2] #['a']

  5. 将输入的字符存入列表里使用.append()

    .append()是在列表的最后追加一个元素

    users=[]
while True :
    name = input('输入姓名：')
    users.append(name)
    print(users)
-------------------------------
users=[]
users.append('alex')
print(users)

  6. 插入.insert(n,'xxx')，在第n个元素前插入xxx

    users=['a','b','c']
users.insert(0,'d')
print('users')

  7. 删除.remove(xxx)如果有两个相同的，只删除第一个

    users.remove('a') #删除users里的a

    .pop(n)n 是索引位置，如果不加索引位置，默认删除最后一个

    delete = users.pop(0)可以将删除的数据存储在delete中，而del仅仅是删除

    users.pop(0) #删除第0个

    clear 清空

    users.clear() #清空列表

  8. 列表的嵌套

    users=['a',1,True,[12,2,'b'],[3,['alex','d'],6]]
users=[3][2] #取2
users=[4][1][0] # 取'alex'

    .extend()习题：将字符出s='abc’添加到列表users中，不使用循环，()可以放元组，字符出，列表

    users.extend(s)

  9. 反转 v1.reverse()

  10. 从小到大排 v1.sort(reverse=False)

    从大到小排v1.sort(serverse=True)

  11. 判断敏感词

    v = ['alex','我','你是谁']
if '我' in v :
    print ('包含敏感词')

元组

  1. 元组的书写规范

    users=[1,2,3,4,5,6] #列表（可变类型）
users=(1,2,3,4,5,6) #元组（不可变类型）

  2. 没有独有功能，只有公共功能

    公共：

    1. 索引

      users=(1,2,3,"a")
print(users[3])

    2. 切片

      users=(1,2,3,"a")
print(users[0:2])

    3. 步长

      users=(1,2,3,"a")
print(users[0:2:2])

    4. 删除（不能删除）

    5. 修改（不能修改）

    6. for循环

      users=(1,2,3,"a")
for i in users:
    print(i)

    7. len

      users=(1,2,3,"a")
print(len(users))

  3. 特殊：元组中的元素不能被删除/修改

    v1 = (11,22,33)
v1[1] = 999 #错误
v1 = 999 # 可以
----------------------
v1 = v1 = (11,22,33,(44,55,66)) # 可以嵌套
----------------------
v2 = [11,22,33,(44,55,66)]
v2[-1][1] = 99 # 错误 ，(44,55,66)里面不能修改，整体可以，因为是列表里的元素
v2[-1] = 123 # 正确
----------------------
v3 = (11,[1,2,3],22,33) #其中的[1,2,3]是元组的元素
v3[1] = 666 # 错误，[1,2,3]是元组的元素，不能修改
v3[1][2] = 123 # 可以

  4. 判断敏感词用 in 同字符串和列表一样

字典

帮助用户表示一个事物的信息（事物有多个属性）

data = {键:值,键:值,键:值}

  1. 获取值

    info = {"name":'郭希文','age':21,'gender':'男'} #键值对
print(info['name'])#取值

  2. 取值，用这个也可以判断字典里是否有这个数据

    info = {'k1':'v1','k2':'v2'}
n = info.get('k111',666) #'k111'是键，当能取到值时取值，当取不到时返回666，如果没设置默认返回None

  3. .values()取值

  4. 输出所有的键/值

    info = {"name":'郭希文','age':21,'gender':'男'}
for i in info.keys():
    print(i)
-----------------------------------
info = {"name":'郭希文','age':21,'gender':'男'}
# for a,b in info.items():
#	print(a,b) #输出所有的键值
for i in info.items() :
    print(i) #输出所有的键值

  5. 输出所有键和值，并让用户输入键，根据用户输入，输出对应的值

    info = {"name":'郭希文','age':21,'gender':'男'}
for k,v in infor.items():
    print(k,v)
key = input('请输入键：') #'name'
print(info[key])  #info['name']

  6. 给一个空字典，请在空字典中添加数据：k1:1,k2:2,k3:3

    info = {}
info['k1'] = '1'
info['k2'] = 2
info['k3'] = 3
print(info)

  7. 给一个空字典，请让用户输入：key，value，将输入的key，value添加到字典里

    info = {}
k = input('请输入key:')
v = input('请输入value:')
info[k] = v
print(info)

  8. 给一个空字典，请让用户一直输入：key，value，将输入的key，value添加到字典里，直到用户输入了N，则表示不在输入

    info = {}
while True :
    k = input('请输入key:')
    if k == 'N' :
        break
    v = input('请输入value:')
    info[k] = v
print(info)

  9. 给一个字符串，message = "k1|v1,k2|v2,k3|123"，转换成字典

    info = {}
message = "k1|v1,k2|v2,k3|123"
for item in message.split(','):
	v1,v2 = item.split('|')
    info[v1] = v2
print(info)

  10. 数据类型嵌套，int/bool/str/list/tuple/dict

列表里边嵌套字典

字典嵌套，列表不能当键，字典不能当键#不可哈希

info = {'k1':'v1','k2':True,'k3':1,'k4':(11,22),'k5':[33,44],'k6':{'kk':'vv'},1:{'kk':'vv'},False:{'kk':'vv'},(11,2):{'kk':'vv'}}

  1. 习题创建一个用户列表，列表里放字典，首先用户输入用户名密码注册，在进行登录

    users_list = []
while True:
    count = 0
    info = {'username':'','password':''}
    name = input('请输入账号:')
    if name == 'N':
        break
    pwd = input('请输入密码:')
    info['username'] = name
    info['password'] = pwd
    users_list.insert(count,info)
    count += 1
print(users_list)
print('注册成功')
---------------------------------------------
k = input('请输入用户名:')
v = input('请输入密码：')
num = len(users_list)
for i in users_list:
    num -= 1
    k1 = i['username']
    v2 = i['password']
    if k == k1 and v == v2 :
        print('登录成功')
        num = 1
        break
    else :
        continue
if num == 0 :
    print('登录失败')

  2. 删除

    info = {'k1':'v1','k2':'v2'}
result = info.pop('k2')
print(info,result) #结果为{'k1':'v1'} v2

    del info['k1'] #也是删除

  3. 更新

    info.updata({'k3':'v3'}) #如果不存在就添加，如果键存在就更新

  4. 判断k1是否在其中？

    if 'k1' in v : #默认判断的是 键

    判断v2是否在其中？

    方式一：

    flag = '不存在'
for v in v.values():
    if v == 'v2':
        flag = '存在'
print(flag)

    方式二：

    if 'v2' in list(v.values()): #将值的整体强制转换为列表，再进行判断
    pass

    判断k2:v2是否在其中?

    value = v.get('k2')
if value == 'v2':
    print ('存在')
else:
    print ('不存在')

  5. 有序：元组，列表

    无序：字典（3.6之后是有序的）

集合

set : v = {1,2,3,4}

无序，不重复的/不能通过索引删除

#v1 = set () 表示空集合

  1. 添加

    v = {1,2}
v.add('a')

  2. 删除

    v = {1,2,'a'}
v.discard('a')

  3. updata，批量添加

    v = {1,2,'a'}
v.updata({11,22,33})

  4. 交集

    v = {1,2,'a'}
result = v.intersection({1,'a'}) #不对集合本身做操作，需要赋值
print(result)

  5. 并集

    v = {1,2,'a'}
result = v.union({1,'a','b'})
print(result)

  6. 差集

    v = {1,2,'a'}
result = v.difference({1,'a','b'}) #输出结果是，v中而{1,'a','b'}没有的
print(result)

  7. 对称差集

    v = {1,2,'a'}
result = v.symmetric_difference({1,'a','b'})
print(result)

  8. len()

  9. for 循环

  10. 集合嵌套

    1. info = {1,2,3,True,‘国风’,None,(4,5)} #列表，字典，集合不能放在集合中，不能作为字典的 键

深浅拷贝

  1. 浅拷贝：拷贝第一次

  2. 深拷贝：拷贝所有数据（可变），有时候由于小数据池使得不可变数据地址一样

  3. import copy

文件操作

  1. file_object = open('log.txt',mode = 'r+',encoding='utf-8') #r+可读可写，r可读，w可写
content = file_object.read()
file_object.write('我')

  2. file_object = open('log.txt',mode='w+',encoding='utf-8') #w，w+ ，会将文件清空，读取时需要调整光标
data = file_object.read()#读不到
print(data)
file_object.write('alex')
file_object.seek(0) #将光标移到第一个
data = file_object.read()
print(data)
file_object.close()

  3. 可读可写 ‘a+’，只要写光标会自动跳到最后

    file_object = open('log.txt',mode = 'a+',encoding='utf-8')#光标默认在最后，读文件是从光标开始读
file_object.seek(0)
data = file_object.read()
print()
file_object.close()

  4. r，只能读 **

  5. w，只能写，写之前清空 **

  6. a，只能追加 *

  7. r+

    1. 读：默认从0的光标开始读，也可以通过seek调整光标位置
    2. 写：从光标所在的位置开始写，也可以通过seek调整光标的位置

    w+

    1. 读：默认光标永远在写入的最后或0，也可以通过seek调整光标位置
    2. 写：先清空

    a+

    1. 读：默认光标在最后，也可以通过seek调整光标位置，然后再去读取
    2. 写：永远写在最后
  8. #写入实例：一般用于图片/音频/视频/未知代码
f = open('a.txt',mode='wb')
#把要写入的字符串转换成二进制
data = '我好困'
content = data.encode('utf-8') #将字符串按 utf-8编码转换成二进制
#再将二进制写入文件中
f.write(content)
f.close()

  9. f = open('a.txt',mode='rb')
#直接读取二进制
data = f.read
f.close()
print(data)

三目运算

如果a>b的结果为真，h=“变量1”,如果为假，h=“变量2”

h = "变量1" if a>b else "变量2"

函数

  1. 局部变量

    1. 在函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是 局部 的。这称为变量的 作用域 。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。

      #局部变量
def func(x):
    print('x is', x)
    x = 2
    print('Changed local x to', x)
print('局部变量')
x = 50
func(x)
print('x is still', x)

      在上面这段代码中，首先函数定义了形参x，相当于函数的局部变量。在函数调用的时候，传入了外部x，外部x值为50。在函数内部将x值改为2，改变的是局部变量x，外部x不受影响，从最后的输出结果可以验证。运行结果如下：

      局部变量
x is 50
Changed local x to 2
x is still 50

    2. 如果你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是 全局 的。我们使用global语句完成这一功能。没有global语句，是不可能为定义在函数外的变量赋值的。例如：

      #访问外部变量
def func2():
    global x
 
    print('x is', x)
    x = 2 #这个x是全局变量
    print('Changed local x to', x)
print('访问外部变量')
x = 50
func2()
print('Value of x is', x)

      运行结果如下：

      访问外部变量
x is 50
Changed local x to 2
Value of x is 2

  2. 默认参数值

    只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。这是因为赋给形参的值是根据位置而赋值的。例如

    def func(a, b=5)

  3. 函数可以当作参数进行传递

    def func (arg):
    arg()
def show ():
    print 999

func(show)

  4. lambda表达式

    lambda表达式，为了解决简单函数的情况

    def func(a1,a2):
    return a1+100

func = lambda a1,a2:a1+100
#这两个是相同的效果

    func1 = lambda:100 # 没有参数，返回100

func2 = lambda x1:x1*10

func3 = lambda *args ,**kwargs : 100

func4 = lambda n1,n2 : n1 if n1 > n2 else n2 #判断大小

  5. 内置函数

    1. 自定义函数

    2. 内置函数

      1. len

      2. open

      3. print

      4. range

      5. max()

      6. min()

      7. sum()

      8. abs() #计算绝对值

      9. pow()

        v = pow(2,3)
print(v)# 2**3 2的3次方

      10. divmod() #计算出商和余数

      11. round()

        v = round (1.123,2) #保留小数点后2位，2可有可无
print (v) #1.12 有默认四舍五入

      12. dict()

      13. list()

      14. tuple()

      15. int()

      16. str()

      17. bool()

  6. 进制转换

    1. bin () 将10进制转化成2进制

    2. oct() 将10进制转换成8进制

    3. hex() 将10进制转换成16进制

    4. int() 将其他进制转换成10进制

      v1 = '0b1101'
result = int(v1,base=2)#指定读的是二进制
print(result) #二进制转换成10进制

    5. 其他

      1. len()
      2. range()
      3. id()
      4. type()
      5. open()

    6. 编码相关

      1. chr()，将十进制数字准换成unicode编码中对应的字符串

      2. ord()，将unicode编码转换成十进制

      3. 生成随机数

        import random
def ger_random_code(length=6):
    data = []
    for i in range(length):
        v = random.randint(65,90)
        data.append(chr(v))
    return ''.join(data)
code = ger_random_code()
print(code)

    7. 高级内置函数

      1. map()循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

        map(x,y) #第一个参数：必须是一个函数，第二个参数：必须是可迭代的类型

        v1 = [11,22,33]
result = map (lambda x:x+100,v1)
print(result) #在python2中会返回[111,122,133]
print(list(result)) #python3中需要使用list转换后才能显示

      2. filter()过滤

        v1 = [11,22,'a',34]
result = filter(lambda x:True if tpye(x) == int else False,v1)#使用lambda来代替func函数
result = filter(lambda x:tpye(x) == int,v1)#更简化
print(list(result))

      3. reduce()

        import functools
v1 = [11,22,33]
def func (x,y):
    return x*y
result = functools.reduce(func,v1)
print(result)
----------------------------------
import functools
v1 = [11,22,33]
result = functools.reduce(lambda x,y:x*y,v1)
print(result)

  7. 模块

    1. md5

      import hashlib
obj = hashlib.md5()
obj.update('123'.encode('utf-8'))
result = obj.hexdigest()
print(result)

    2.加盐

    import hashlib
obj = hashlib.md5('qwesdsafewafewafaef123d'.encode('utf-8'))
obj.update('123'.encode('utf-8'))
result = obj.hexdigest()
print(result)

  8. 装饰器

    在不改变原函数的情况下，在函数之前或者之后做操作

    def func(arg):
    def inner():
        print('before')
        v = arg()
        print('after')
        return v
    return inner

def index():
    print('123')
    return '666'

index = func(index)
index()

    def func(arg):
    def inner():
        print('before')
        v = arg()
        print('after')
        return v
    return inner

@func #第一步：执行func函数并将下面的函数当作参数传递。相当于：func(index)
	  #第二步：将func的返回值重新赋值给下面的函数名。index = func(index)
def index():
    print('123')
    return '666'

index()
文章作者： Sugarbeet
本文链接：
版权声明： 本站所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 Sugarbeet's Blog！
学习 潜心
喜欢就支持一下吧