python基础一

一、变量

二、基本数据类型

三、控制台交互

四、运算符

五、可变不可变类型

六、条件判断

七、深cope和浅cope

八、while循环(条件循环)

九、for循环(迭代循环)

十、数字类型

十一、字符串类型

十二、列表类型

十三、元组

十四、字典类型

十五、集合

字典内置方法

一、变量

常用快捷键：
ctrl+?  添加注释
ctrl+D  复制
ctrl+alt+L  格式化代码格式
r可以转义\

1.变量：先定义,后引用

name = 'admin'   # 定义变量name，值为'admin'
print(name)    # 引用变量name，输出：admin
age = 18       # 定义变量age，值为18
print(age)     # 引用变量age，输出：18

2.内存管理：垃圾回收机制

# 垃圾：当一个变量值被绑定的变量名的个数为0时，该变量值无法访问到
# 引用计数增加
x = 10  # 10的引用计数为1
y = x   # 10的引用计数为2  
z = x   # 10的引用计数为3

# 引用计数减少
del x   # 解除变量名x与值10的绑定关系，之后10的引用计数为2
print(y, z)  # 输出：10 10
del y   # 10的引用计数为1
print(z)     # 输出：10
z = 12345    # 10的引用计数为0，被垃圾回收
print(z)     # 输出：12345

3.变量三大组成部分

变量三大组成部分：
i：变量名 - 指向等号右侧值的内存地址，用来访问等号右侧的值
ii：赋值符号= - 将变量值的内存地址绑定给变量名  
iii：变量值 - 代表记录事务的状态

4.变量名的命名风格

# 风格一：驼峰体
AgeOfTony = 56
NumberOfStudents = 80

# 风格二：纯小写下划线(在python中，变量名的命名推荐使用该风格)
age_of_tony = 56
number_of_students = 80

5.变量值的三个重要特征

name = 'admin'
# id：反应变量值的内存地址
print(id(name))
# type：不同类型的值表示记录的不同状态  
print(type(name))
# value：值本身
print(name)

6.is与==

x = 'info:Egon:18'
y = 'info:Egon:18'
# is：比较左右两个值身份id是否相等
print(id(x), id(y))  # 两个不同的内存地址
print(x is y)        # 输出：False
# ==：比较左右两个值是否相等
print(x == y)        # 输出：True

7.常量：不变的量

AGE_OF_ALEX = 73 # 小写字母全为大写代表常量，只是一种命名规范

二、基本数据类型

# 注意：有序代表可以通过x[]来取到，无序也就是无索引代表不能通过这种方式来取
# 有序（有索引）：字符串、列表、元组
# 无序（无索引）：字典，集合，
# 一切皆对象 int、dict都是个对象

1、数字类型

1.1整型int

age=18
print(type(age)) # int

1.2浮点型float

height=1.7
print(type(height))

2、字符串类型str

name='admin'
print(name,type(name))
#字符串嵌套，外层用单引号，内层用双引号
print("my name is 'admin'")
print("my name is \'admin\'")
#字符串可以相加成，效率低一般不用
print('a'+'b')
print('a'*5)

3、列表(list)：索引对应值，正向索引从0开始,反向索引从-1开始

x=['a','b','c',10,['d','e','f']] #定义,列表内可以嵌套列表
print(x)
print(x[1],x[4])
print(x[1],x[4][1])
print(x[-1])

#取第一个学生第一个爱好
students_info=[
    ['b',18,[0,1,2]],
    ['j',19,[3,4,5]],
    ['k',20,[6,7,8]]
]
print(students_info[0][2][0])

4、字典(dict)：key对应值，其中key通常为字符串类型，所以key对值可以有描述功能

x={'a':1,'b':2}  #定义
print(x['a'])

# 字典可以嵌套
info={
    "name":'admin',
    "age":18,
    "hobbies":['play','sleep']
}
print(info["hobbies"])
print(info["hobbies"][0])

# 列表内嵌入字典
student=[
    {"name":'b',"age":18,"hobbies":['a','b']},
    {"name":'j',"age":19,"hobbies":['c','d']},
    {"name":'k',"age":10,"hobbies":['e','f']}
]
print(student[1]["hobbies"][0])

5、布尔类型(bool) 记录真假两种状态 True False

# 所有值都是布尔值，除去隐式布尔值都为真
# 隐式布尔值0、None、空(空字符串、空列表、空字典)为假
'''
is_ok = True
i = False
print(i == is_ok)

三、控制台交互

1、接收用户的输入

# python3中inpout会将用户输入的内容都存成字符串类型
name = input("请输入姓名：")
print(name, type(name))

age = input("请输入年龄：")
age = int(age)  # int只能将纯数字转为整型
print(age, type(age))

2、格式化输出

2.1、值按照位置与%s一一对应，数量要相同

x="我的名字%s我的年龄%s" %('admin',18)
print(x)

#以字典的形式传值，打破位置的限制
x="我的名字%(name)s我的年龄%(age)s" %{"name":'admin',"age":18}
print(x)
x="我的年龄%s" %{"age":18}
print(x)

# %d只能接收int类型 %s可以接收任意类型
x="我的名字%d我的年龄%d" %(10,18)
print(x)

# 如果要输出%要用%%
print('%d%%' %10)

2.2、函数：str.format python版本通用

name = input("请输入名字：")
age = input("请输入年龄：")
# 按照位置
x = '我的名字是{0}{0}我的年龄{1}{1}'.format(name, age)
print(x)

# 按照key=value传值
x = '我的名字是{Name}我的年龄{Age}'.format(Name=name, Age=age)
print(x)

2.3、f pyhton3.5之后才可以用

x = f'我的名字是{name}我的年龄{age}'
print(x)

name = input("请输入姓名：")
age = input("请输入年龄：")
sex = input("请输入性别：")
age = int(age)
x = ("我的名字是：{Name}"
     "\n我的年龄是：{Age}"
     "\n我的性别是：{Sex}").format(Name=name, Age=age, Sex=sex)
print(x)

# 如果x的值不够10就用=去填充
print("{x:=<10}".format(x='开始'))
print("{x:=>10}".format(x='开始'))
print("{x:=^10}".format(x='开始'))
#保留小数点后三位，四舍五入
print("{x:.3f}".format(x=12345.6789))

# print换行方式
print('hello',end='*')
print('hello')
print('hello\n''hello')

# \r打印跑到行首，end=''不换行，合在一起就是打印覆盖
print('\r[%-50s]' % #, end='')

四、运算符

1、算术运算符

print(10+3)
print(10/3)   # 带小数
print(10//3)  # 只保留整数部分
print(10%3)   # 取模，取余数
print(10*3)   #相乘
print(10**3)  # 3个10相乘

2、比较运算符

print(10>3)
print(10==3)
print(10!=3)  #不等于
print(10 is 3)  # is比对id
name=input("你的名字：")
print(name=="admin")  # ==比对值

3、赋值运算符

age=8
age +=2  #在原来的基础上加2
print(age)
age *=3  #在原来的基础上乘3
print(age)
age **=3  #age=age**3 三个age相乘
print(age)
age //=3  #在原来的基础上除3
print(age)
age %=3  #取余数
print(age)

3.1、链式赋值

x = y = z = 10
print(x, y, z)
print(id(x), id(y), id(z))

3.2、交叉赋值

m = 10
n = 20
m, n = n, m  # 交叉赋值
print(m, n)

3.3、解压赋值

x = [1, 2, 3]
print(x[0], x[1], x[2])
mon0, mon1, mon2 = x  # 左右对应个数要一致
print(mon0, mon1, mon2)
# 引入*
mon3,*_ = x  # 如果取其中几个就用*_代替,把多余的变量值赋值给了_
print(mon3)
*_, mon6 = x
print(mon6)

4、逻辑运算符

4.1、not：把紧跟其后的那个条件是结果取反,not两边为不可分割的整体

print(not 15 < 13)
print(not True)
print(not False)

4.2、and：逻辑与，用来连接左右两个条件，必须使之全部成立才为真

print(True and 10 > 3 and 5 < 10)
print(True and 10 > 3 and 5 < 1)

4.3、or：逻辑或，or用来链接左右两个条件，但凡有一个为True最终结果就为True

print(False or 10 > 3 or 5 < 1)
print(False or 10 < 3 or 5 < 1)

# 优先级not>and>or  ()可以改变优先级
# 列如：3>4 and not 4>3 or 1==3 and 'x'=='x' or 3>3
x = 3 > 4 and (not 4 > 3) or 1 == 3 and 'x' == 'x' or 3 > 3  # 先提取not
x = (3 > 4 and (not 4 > 3)) or (1 == 3 and 'x' == 'x') or 3 > 3  # 提取and
print(x)

5、成员运算符 (字符串、字典、集合)

# in 判断左侧是否存在与右侧
print('a' in 'abcd')
print('ad' in 'abcd')

# not in 判断左侧是否不存在与右侧
print('a' not in 'abcd')
print('ad' not in 'abcd')

五、可变不可变类型

# 可变类型：值改变，id不变，证明改的是原值，原值是可以被改变的
# 不可变类型：值改变，id也变，证明原值是不可以被改变的，产生的是新值开辟了新的堆空间
# python的参数在传递过程中都是copy一份传递的，传过去的都是地址
# 可变类型在函数中修改会改变原值，不可变类型在函数中修改不会改变原值
# 可变：列表，字典，集合
# 不可变：数字，字符串，元组

1、int是不可变类型

x = 10
print(id(x))
x = 11  # 产生了新值
print(id(x))

2、float是不可变类型

x = 10.1
print(id(x))
x = 11.1  # 产生了新值
print(id(x))

3、str是不可变类型

x = "abc"
print(id(x))
x = "def"
print(id(x))
#小结：int、float、str都被设计成了不可分割的整体，不能被改变

4、list是可变类型

x = ['abc', 'def', 'ghi']
print(id(x))
x[0] = 'xxx'
print(id(x))

5、dict是可变类型

dict = {'b': 1, 'j': 2, 'k': 3}
print(id(dict))
dict['b'] = 4
print(id(dict))

6、bool不可变

7、元组为不可变类型

字典补充：

# 定义：{}内用逗号分割开多个key：value
# 其中value可以是任意类型，但是key必须是不可变类型,并且不能重复，可以hash

info = {
    "name": 'admin',
    1: 18,
    1.1: ['play', 'sleep'],
    True: 0
}
print(info)
print(info[1.1][1])

六、条件判断

# 条件可以是：比较运算符
# 条件可以是：bool类型 True False

1、if

1.1、语法1：

if 条件:
    代码1
    代码2

x = input('请输入年龄：')
x = int(x)
if x >= 18:
    print('ok')

1.2、语法2：

if 条件:
    代码1
    代码2
else:
    代码3
    代码4

x = input('请输入年龄：')
x = int(x)
if x >= 18:
    print('ok')
else:
    print('no')

1.3、语法3：

if 条件1:
    代码1
    代码2
elif 条件2:
    代码3
    代码4
else:
    代码5
    代码6

x = input("请输入成绩：")
x = int(x)
if x >= 90:
    print('A')
elif x >= 80:
    print('B')
elif x >= 60:
    print('C')
else:
    print('D')

if嵌套if

x = input('请输入年龄')
x = int(x)
if x >= 18:
    print('ok')
    but = True
    if but:
        print('ok')
else:
    print('no')

七、深cope和浅cope

# copy和连接是有区别的
# copy是开辟一个一模一样的新的空间
# 连接，在本质上内存空间没有开辟，还是用的之前的空间，本质还是一个
x = [
    'b',
    'j',
    'k',
    'admin'
]
x1 = x

1、浅copy：把列表的第一层的内存地址完成copy一份给新的列表，并没有改变储存

# 深copy：把可变类型加以区分，可变类型开辟新的空间，不可变类型空间位置不变
# 原变量=>原内存地址=>原储存空间
# 浅copy：新变量=>新内存地址=>原储存空间
# 深copy：新变量=>新内存地址=>新储存空间
# 浅copy之后会出现新的变量名和内存地址，指向原来的存储空间，当原值发生改变，copy前后的变量的值都会改变

x = [
    'b',     #不可变类型
    'j',
    'k',
    ['admin', 'pwd']  # 可变类型
]
x1 = x.copy()  # copy函数
print(x, id(x),id(x[0]), id(x[3]))
print(x1,id(x1),id(x1[0]), id(x1[3]))
# 实际上浅copy虽然分开了列表，但是里面元素空间位置并没有改变
# 可变类型的id并没有变化，元素都没有没有开辟新的空间，没有把两个列表完全分割开

2、深copy：把可变类型加以区分，可变类型开辟新的空间，不可变类型空间位置不变

import copy  # 导入功能包
x = [
    'b',  # 不可变类型
    'j',
    'k',
    ['admin', 'pwd']  # 可变类型
]
x2 = copy.deepcopy(x)  # copy.deepcopy()深copy函数
print(x, id(x), id(x[0]), id(x[3]))
print(x2, id(x2), id(x2[0]), id(x2[3]))
# 得到结果，可变类型的id值发生了改变，说明开辟了新的空间，而不可变类型没有改变

八、while循环(条件循环)

1、循环次数取决于条件，如果条件为真，则依次循环运行代码

1.1、语法

while 条件：
    代码1
    代码2
    代码3

x = 0
while x < 5:
    print('111')
    x += 1

1.2、while循环应用

username = 'admin'
password = 'admin'

x = True      #第一种终止循环
while x:
    user_id = input("请输入id：")
    user_pwd = input("请输入密码：")
    if user_id == username and user_pwd == password:
        print('ok')
        print('登陆成功')
        x = False  # 结束循环，之后的代码还会运行，下次循环开始时生效
    else:
        print('no')
    print('=========')   #不管循环成立与否都会输出

# 第二种终止循环 break，只要运行到直接停止运行
while True:
    user_id = input("请输入id：")
    user_pwd = input("请输入密码：")
    if user_id == username and user_pwd == password:
        print('ok')
        print('登陆成功')
        break
    else:
        print('no')
    print('=========')  # 只有在不成立才会运行


# 将条件设为统一的值可以一次终止多个循环
x = True
while x:
    while x:
        while x:
            x = False
# 如果使用break就要每层添加一个
while True:
    while True:
        while True:
            break
        break
    break

2、 while循环的嵌套、终止

username = 'admin'
password = 'admin'

# 使用break终止
while True:
    user_id = input("请输入id：")
    user_pwd = input("请输入密码：")
    if user_id == username and user_pwd == password:
        print('ok')
        print('登陆成功')
        while True:
            x = input("请输入命令：")
            if x == 'q':
                break
            print("正在执行命令{cmd}".format(cmd=x))
        break  #在id和密码正确的情况下终止外循环
    else:
        print('no')

# 使用tag终止
username = 'admin'
password = 'admin'
tag = True
while tag:
    user_id = input("请输入id：")
    user_pwd = input("请输入密码：")
    if user_id == username and user_pwd == password:
        print('ok')
        print('登陆成功')
        while tag:
            x = input("请输入命令：")
            if x == 'q':
                tag = False
            else:  # 如果不加else,则会在终止前在运行一次下面的代码
                print("正在执行命令{cmd}".format(cmd=x))
    else:
        print('no')

3、while + continue：结束本次循环，直接进入下一次

x = 0
while x < 6:
    if x == 4:
        x += 1
        continue  # continue之后添加同级代码没有意义，永远也无法到达
    else:
        print(x)
        x += 1

4、while + else 针对break

x = 0
while x < 6:
    print(x)
    x += 1
else:
    print('else包含的代码只会在while循环完之后打印，并且while没有被break打断')

x = 0
while x < 6:
    if x==4:
        break   #被break打断
    print(x)
    x += 1

else:
    print('else包含的代码只会在while循环完之后打印，并且while没有被break打断')

案例演示 输错三次就退出

conut = 0  # 计数器
username = 'admin'
password = 'admin'
while conut < 3:
    user_id = input("请输入id：")
    user_pwd = input("请输入密码：")

    if user_id == username and user_pwd == password:
        print('登陆成功')
        while True:
            x = input("请输入命令：")
            if x == 'q':
                break
            print("正在执行命令{cmd}".format(cmd=x))
        break  # 在id和密码正确的情况下终止外循环

    else:
        print('no')
        conut += 1  # 错误次数加1
else:
    print('错误三次退出')

九、for循环(迭代循环)

1、循环次数取决于迭代对象，在遍历循环取值方面比while循环更好

# 语法：
for 变量名 in 可迭代对象:  #可迭代对象可以是：列表、字典、字符串、元组、集合
    代码1
    代码2

# 注意：
# for循环强制终止只有break一种方式
# 在循环内尽量不要改in 后面的东西

# 案例1：循环取值
x=['alex_admin', 'lxx_admin', 'xxx_admin']
for i in x:    #把第一个元素赋值给i,后面第二个第三个依次赋值
    print(i)  # 依次取出集合的元素，for循环的循环次数取决于集合的元素个数

# while循环
i = 0
x = ['alex_admin', 'lxx_admin', 'xxx_admin']
while i < 3:
    print(x[i])
    i += 1

# 案例2：字典循环取值
dic = {'k1': 111, 'k2': 222, 'k3': 333}
for x in dic:
    print(x, dic[x])

# 案例3：字符串循环取值
msg="you can you up,no can no bb"
for k in msg:
    print(k) #每个字符都取出来输出

2、总结for循环与while循环

# for循环能干的事while循坏也可以干
# while循环(条件循环)：循环次数取决于条件，
# for循环(迭代循环)：循环次数取决于迭代对象

3、for循环控制循环次数：range() 从0开始，尾取不到

'

# range(10)  表示从0-9
# range(1,10) 表示从1开始到9
# range(1,10,1)  最后一个1为步长,默认为1,如果为2则得出1,3,5,7,9

for i in range(3):
    print(i)

# 案例演示 输错三次就退出
user_id = 'admin'
user_pwd = 'admin'
for i in range(3):
    x = input("请输入id：")
    y = input("请输入密码：")
    if x == user_id and y == user_pwd:
        print("ok")
        while True:
            x = input("请输入命令：")
            if x == 'q':
                break
            print("正在执行命令{cmd}".format(cmd=x))
        break  # 在id和密码正确的情况下终止外循环
    else:
        print("no")
else:
    print("三次错误，退出")

4、for+continue

for i in range(6):  #0 1 2 3 4 5
    if i == 4:
        continue
    print(i)

5、for循环嵌套

for i in range(2):
    print('外循环', i)
    for j in range(3):
        print('内循环', j)

6、获取列表长度

x = ['b', 'j', 'k', 'b']
print(len(x))  #从1开始计数

十、数字类型

1、int类型

# age = 10  # age = int(10)
# 名字(参数)

1.1、类型转换

res=int('10089')
print(res,type(res))

1.2进制转换

print(bin(11))  # 十进制转二进制
print(oct(11))  # 十进制转八进制
print(hex(11))  # 十进制转十六进制

print(int('0b1011', 2))  # 二进制转十进制
print(int('0o13', 8))  # 二进制转八进制
print(int('0xb', 16))  # 二进制转十六进制

2、float类型

# salary=3.14 #salary=float(3.14)

2.1、类型转换

res=float('10089')
print(res,type(res))
# int与float没有要掌握的内置方法

十一、字符串类型

1、按索引取值：只能取不能修改

msg='hello world'
# 1.1、正向取
print(msg[0])
# 1.2、反向取
print(msg[-1])

2、切片(顾头不顾尾,从0开始)，得到列表

# aList[start:stop:step]
# 头:尾:步长。可以省略，方向由步长的正负决定
msg = 'hello world'
x = msg[0:5]  # 0,1,2,3,4
print(x)
x = msg[0:5:2]  # 0,1,2,3,4 步长为2时,取0,2,4
print(x)

2.1、反向步长

msg = 'hello world'
res = msg[5:0:-1]  # 从空格开始取取到e，因为头可以取到也就是正数0-5
print(res)

2.2、不写相当于全取，省略了头尾

msg = 'hello world'
res = msg[:]  #把字符串全取
print(res)

2.3、把字符串倒过来

# 实际就是省略了头尾，全取，然后步长为-1倒这取
msg = 'hello world'
res = msg[::-1]  # 反向步长取倒置
res1= msg[:]
print(res)
print(res1)

3、 成员运算in和not in(字符串、字典、集合)

# 判断左侧字符串是否存在与右侧字符串中
# print('admin' in 'admin is good boy')

4、移除两侧空格strip，并不会去除中间 #在函数需要传入的参数中看到self就当作不存在

msg = '   admin   '
x = msg.strip()  # 默认去掉空格
print(x)  # 是产生了新的值

msg = '****admin****'
x = msg.strip('*')
print(x)  # 是产生了新的值

msg = '**/*=-()admin*-=*()*'
x = msg.strip('*/=-()')  # 去除多个元素
print(x)

5、切分split：把一个字符串按照某种分隔符进行切分，得到一个列表

info = 'admin:18:man'
x = info.split(':', 1)  # 默认按照空格为分割符,1代表分割次数
x1, x2, x3 = info.split(':')  # 可以依次赋值得出的不是列表
print(x)
print(x1)
print(x2)
print(x3)

6、循环

info = 'admin:18:man'
for x in info:
    print(x)  # 把字符挨个取出来循环输出

7、strip、lstrip、rstrip

msg = '****admin****'
print(msg.strip('*'))  # 去除两边*
print(msg.lstrip('*'))  # 去除左边*
print(msg.rstrip('*'))  # 去除右边*

8、lower、upper

msg = 'AbbCCC'
print(msg.lower())  # 全改为小写
print(msg.upper())  # 全改为大写

9、startswith、endswith

print("admin is good boy".startswith('admin'))  # 判断是否以admin为开头
print("admin is good boy".endswith('boy'))  # 判断是否以boy为结尾

10、split、rsplit

info = "admin:18:mam"
print(info.split(':', 1))  # 从左往右切
print(info.rsplit(':', 1))  # 从右往左切

11、join：把列表拼接成字符串，只能是字符串

x = ['admin', '18', 'man']
y = ":".join(x)  # 按照某个分隔符，把为纯字符串的列表，把列表的元素拼接为一个字符串
print(y)

12、replace

msg = "you can you up no can no bb"
print(msg.replace("you", "YOU"))  # 把字符串里的you全部改为YOU
print(msg.replace("you", "YOU", 1))  # 只把字符串里的第一个you改为YOU

13、isdigit()

# 判断字符串是否由纯数字组成
print('123'.isdigit())
print('123d'.isdigit())
# 案例
while True:
    x = input("请输入年龄：").strip()
    if x.isdigit():
        x = int(x)
        if x > 18:
            print('大了')
        if x < 18:
            print('小了')
        else:
            print('对了')
            break
    else:
        print('no str')

14、find、rfind、index、rindex、count

msg = 'admin is 18 age a man'
print(msg.find('a'))  # 返回要查找的字符串在大字符串里的起始索引
print(msg.rfind('a'))  # 返回要查找的字符串在大字符串里的反向索引
print(msg.index('a'))  # 返回要查找的字符串在大字符串里的起始索引
print(msg.rindex('a'))  # 返回要查找的字符串在大字符串里的反向索引
print(msg.find('xxx'))  # 找不到返回-1
print(msg.count('a'))  # 统计字符串在大字符串里出现的次数

15、center、ljust、rjust、zfill

print('admin'.center(50, '*'))  # 在输出两侧添加*号填充至50字符
print('admin'.ljust(50, '*'))  # 在输出右侧添加*号填充至50字符
print('admin'.rjust(50, '*'))  # 在输出左侧添加*号填充至50字符
print('admin'.zfill(50))  # 在输出左侧添加0填充至50字符

16、capitalize、swapcase、title

print('admin is 18 age a man'.capitalize())  # 使字符串第一个字符大写
print('admin Is 18 age A man'.swapcase())  # 使字符串字符大小写反转
print('admin is 18 age a man'.title())  # 使字符串的每一段第一个字符大写

17、is系列、 isdigit()方法检测字符串是否只由数字组成

print('123456admin'.isdigit())  # 字符串由数字组成结果为True
print('123456admin'.isalnum())  # 字符串由字母或数字组成结果为True
print('admin'.isalpha())  # 字符串由字母组成结果为True

十二、列表类型

1、类型转换：但凡能被for循环遍历的类型都可以当作参数传给list()转成列表

# 列表、字典、字符串、元组、集合
#类型转化
res = list('hello')
print(res)

l = []
for x in 'hello':
    l.append(x)  # 把字符串的每个字符都放入列表l的末尾位置
print(l)

2、按索引取值：可取可改

l = [111, 'admin', 'hello']
print(l[0])  # 正向取
print(l[-1])  # 反向取
# 可以修改，索引存在则修改对应的值
l[0] = 123
print(l)
# 不可以修改不存在的索引
# l[3]=456
# print(l)

3、添加

3.1、追加append

l = [111, 'admin', 'hello']
l.append(333)  #在列表末尾追加
print(l)

3.2、插入insert

l = [111, 'admin', 'hello']
l.insert(1, 123)  # 1代表从第一个开始插，插入123
print(l)

# 案例 把列表的元素放入另一个列表
new_l = [1, 2, 3]
l = [111, 'admin', 'hello']
for x in new_l:
    l.append(x)
print(l)

# extend实现上述案例：里面的参数为可迭代对象:列表、字典、字符串、元组、集合
new_l = [1, 2, 3]
l = [111, 'admin', 'hello']
l.extend(new_l)  # 把new_l列表的元素依次放入l列表
l.extend('abc')  # 把字符串的每个字符依次放入l列表
print(l)

4、删除

4.1、del：通用的方法，没有返回值

l = [111, 'admin', 'hello']
del l[0]
print(l)

4.2、pop：根据索引删除，有返回值

l = [111, 'admin', 'hello']
l.pop()  # 不指定索引就删最后一个
x = l.pop()  # 可以把返回值赋值给一个变量
print(l)
print(x)  # 得出的是删除的那个元素

4.3、remove：根据元素删除，没有返回值

l = [111, 'admin', 'hello', [1, 2, 3], 'bss']
l.remove([1,2,3])
print(l)

5、切片(顾头不顾尾，步长):相当于copy，而且是浅copy

l = [111, 'admin', 'hello', 'a', 'b', 'c']
print(l[0:3])  # 0,1,2
print(l[0:3:2])  # 0 2
print(l[0:len(l)])  # 全切
print(l[:])  # 全切

6、长度len

print(len([1,2,3]))

7、成员变量in和not in

print('aaa' in ['aaa','abc','bbb'])
print('aaa' not in ['aaa','abc','bbb'])

8、循环

x = [1, 2, 'a', 'b']
for i in x:
    print(i)

9、其他操作

l = [111, 222, 'aaa', 'bbb']

# count:找111在l里面出现的次数
print(l.count(111))

# index:找到aaa所在的第一个索引，找不到报错
print(l.index('aaa'))

# clear：清空列表
print(l.clear())  

# reverse： 直接把列表倒过来，不是排序
l.reverse()
print(l)

sort：默认从小到大排序，升序，必须是同种类型的数据类型

l = [222, 111, 333, 444]    #如果是字符串则比较的ASCII码
l.sort()  # 升序
print(l)
l.sort(reverse=True)  # 降序
print(l)
# 补充
# 队列：先进先出
# 堆栈：先进后出

十三、元组

1、 元组(tuple)就是一个不可变的列表,只读不改,存放不改的值最好用元组

t = (1.1, 1, 'aa')
print(t, type(t))
t = (1,)  # 如果元组中只有一个元素要加逗号，不然会是int类型
print(t, type(t))

# 不可变(栈和堆对应的内存地址不变，即第一层不变)
t = (1, 'aa', [11, 22])
# t[0]=111  #修改的第一层不能改变
# t[2]=222    #修改的第一层不能改变
t[2][1] = 33  # 修改的第二层可以改变

2、类型转换

print(tuple('123'))
print(tuple([1, 2, 3]))
print(tuple({'a': 1, 'b': 2, 'c': 3}))

3、按索引取值：只能取

t = (1, 2, 'admin')
print(t[0])

4、切片(顾头不顾尾)

t = (1, 2, 'admin')
print(t[0:2])
print(t[::-1])

5、长度len

t = (1, 2, 'admin')
print(len(t))

6、成员变量in和ont in

t = (1, 2, 'admin')
print('aa' in t)

7、循环

t = (1, 2, 'admin')
for x in t:
    print(x)

8、index:统计元素的起始位置

t=(1,2,1,4,5,'aa')
print(t.index(1))

9、count:统计元素的个数

t=(1,2,1,4,5,'aa')
print(t.count(1))

十四、字典类型

1、字典(dict)：{}内用逗号分割开多个key:value

# 字典的内存地址就是value
# 其中value可以是任意类型，但是key必须是不可变类型,并且不能重复
d = {'k1': 111, (1, 2, 3): 222}
print(d['k1'])
print(d[(1, 2, 3)])

# 类型转换
d=dict(x=1,y=2,z=3)
print(d)

2、造字典

d={}
d['key']=111
print(d)

info = [
    ['name', 'admin'],
    ['age', 18],
    ['sex', 'man']
]
res = {}
for k in info:          # for k,v in info:
    print(k)
    res[k[0]] = k[1]    # res[k] = v
# res = dict(info)      使用dict可以直接转换为字典
print(res)

key = ['name', 'age', 'sex']
d = {}
for k in key:
    d[k] = None
print(d)

key = ['name', 'age', 'sex']
d={}.fromkeys(key,111)
print(d)

3、按key存取值：可存可取,取值也可以用[],也可以使用.get

d = {'k1': 111}
x=d.get('k1')
print(x)
d['k1'] = 222
print(d)
print(d['k1'])
# # 如果key不存在则会创建一个key
# d['k2'] = 333
#
# print(d)

4、长度len

d = {'k1': 111, 'k1': 222, 'k3': 333}
print(d)
print(len(d))      #统计的key的个数

5、成员变量in和not in

d = {'k1': 111, 'k2': 222, 'k3': 333}
print('k1' in d)  # 判断的是key是否存在
print(111 in d)

6、删除

6.1、通用删除del

d = {'k1': 111, 'k2': 222, 'k3': 333}
del d['k1']
print(d)

6.2、pop删除

d = {'k1': 111, 'k2': 222, 'k3': 333}
res = d.pop('k2')  # 根据key删除，有返回值，
print(res)  # 返回的删除的key对应的值

6.3、popitem删除:随机删除，返回元组(删除的key,删除的value)

d = {'k1': 111, 'k2': 222, 'k3': 333}
res = d.popitem()
print(res)

7、键key()、值values()、键值对 items()

d = {'k1': 111, 'k2': 222, 'k3': 333}
print(d.keys())
print(d.values())
print(d.items())

for k in d:  #默认取的是key
    print(k)
for k in d.values():
    print(k)
for k,v in d.items():
    print(k,v)

8、删除

d = {'k1': 111, 'k2': 222, 'k3': 333}
# clear:把字典的元素全部删除
d.clear()

update:更新字典

d.update({'k1': 222, 'k3': 222})
print(d)    # {'k1': 222, 'k2': 222, 'k3': 222}

取值

# get:查找key的对应值，key不存在不报错
print(d.get('k1'))

# setdefault:查看key是否存在，如果不存在就添加进去并写入value值
d.setdefault('k4', 333)
print(d)
x = d.setdefault('k1', 333)  # 返回值为添加的value值，如果没添加就返回对应kye的value值
print(x)

x={'a':[1,2,3,4]}
print(x['a'][1])

十五、集合

1、集合(set)：处理整体之间的关系

# for循环的方式取出相同的元素
x1 = {"admin", 'bss'}
x2 = {"b", "j", "admin"}
x = []
for i in x1:
    print(i)
    if i in x2:
        x.append(i)
print(x)

2、定义：在{}内用逗号分隔开多个元素，有以下特点

# 集合内的元素必须为不可变类型
# 集合内的元素无序
# 集合内的元素没有重复
# s=set()    #set：定义空集合

3、类型转换

res=set('hellloll')
print(res)  #会去除重复的字符串

x1 = {"admin", 'bss'}
x2 = {"b", "j", "admin"}

4、取交集

res = x1 & x2
print(res)

5、取并集

print(x1 | x2)

6、取差集:有顺序，左侧减右侧

print(x1 - x2)

7、取对称差集

print(x1 ^ x2)

8、利用set去重(通常不用)

# 只能针对不可变类型去重
l=['11',11,22,'22',11,22]
l=list(set(l))
print(l)
# 无法保证原来的顺序

字典内置方法

1、长度

s={'a','b','c'}
print(len(s))

2、成员运算

print('c' in s)

3、循环

for item in s:
    print(item)

4、删除

s = {'a', 'b', 'c'}
# del(s) #通用删除
# discard：删除该元素，如果没有不报错
s.discard('a')
print(s)

5、更新update:等同于添加，但是可以添加多个

s.update({1, 2, 3})
print(s)

6、add：只能添加单个

s.add(5)
print(s)

7、判断两个集合是否有重复的:没有重复为True

s = {'a', 'b', 'c'}
y = {1,2,3}
sre=s.isdisjoint(y)
print(sre)

8、字典去重

with open(r'xx.txt',mode='rt',encoding='utf-8') as f,\
        open(r'xxx.txt',mode='wt',encoding='utf-8') as f1:
    test=f.read()
    res=test.split('，') # 按照，切分开写入集合
    # res=set(res)    # 使用集合去重
    x=0
    while x < len(res):
        y = 1
        k=res[x]
        while x+y < len(res):
            v=res[y+x]
            y+=1
            if k == v:
                res.remove(v)
        x += 1
    for i in res:
         f1.write(i.strip(' ')+'\n')