Python基础----持续更新

一,python基础

强类型语言,动态语言--------------解释型语言

注释

 ## 单行注释
 ​
 以'#'开始 :#...............
 ​
 ## 多行注释
 ​
 格式:'''  '''

快捷键

关键字

  • 布尔运算关键字。and、or、not。

  • 控制流关键字。if、else、elif、while、for、break、continue、pass。

  • 函数关键字。def、return、lambda。

  • 异常处理关键字。try、except、finally、raise。

  • 类与对象关键字。class、object、is、super。

  • 其他关键字。import、from、as、global、nonlocal、del、assert、in、with、yield。

语句

能够完整的表达某个意思,用最短的代码来完成逻辑闭环。称之为语句。

输出语句

print("我是输出语句")

输入语句

在控制台内,输入内容

input(“请输入内容”)

缩进格式

普通的语句,从左边开始写

语句块:首行不需要缩进

函数快:注意逻辑缩进

变量

1.会变的量。在python,不需要声明变量。

2.变量使用之前,必须要先赋值

3.python中允许同时出现多个变量进行赋值

变量的声明

 变量声明:
     变量值=值 ,右侧的值放在左侧的变量中
     如果这个变量第一次出现,创建
     如果这个变量再次出现,则修改变量的值
     
     name="xxx"     name=xxx
     name="yyy"     name=yyy

变量的命名规则·

 所有自己命令的内容都叫做 标识符
 命名规则:
        1.数字,字母,下划线组成,数字不能开头
        2.见明之意
        3.驼峰明名法
        4.不能和系统关键字重名
        5.不能和保留函数重名
        6。严格区分大小写

常量

常量不会改变,在程序运行过程中,是不会发生改变的。

命名规则: 所有的字母都是大写。

数据类型

 ##数据类型
 '''
 两大类:
     可变数据类型:
         列表,字典,集合
     不可变数据类型:
         数字,字符串,布尔,元组,冰冻集合
 '''
 ​
 ​
 '''
     数字类型------number
         三大类:int(整形),float(浮点),complex(复数)
 '''
 ​
 ​

数字

 '''
 #十进制整数   以0b开头
 decimal=10#二进制整数
 binary=0b1010101
 #八进制整数     以0o开头
 oct=0o2473272   
 ​
 #十六进制整数   以0x开头
 hex=0x44832
 '''
 #将一个数值,按照8进制来转换2,10,16
 num="52"
 #8->2
 print(f"8进制的{num}-->2进制:",bin(int(num,8)))
 #8->10
 print(f"8进制的{num}-->10进制:",(int(num,8)))
 #8->16
 print(f"8进制的{num}->2进制:",hex(int(num,8)))

字符串类型

 '''
 字符串:由多个文本或字符组成的一句话
 表述方法:
     "",
     '',
     ''''''
 '''
 ​
 s="那个女孩对我说:'说我是一个小偷'"
 print(type(s))
 s1='''那个女孩对我说:
 说我是一
         个小偷'''
 print(s1)

字符串的模式

 ''' 
 字符串的模式:
     f"" :格式化 ,字符串的{} 里面写上变量
     b"":字符转化为二进制
     r"": raw字符串,字符串中所有的内容都会简单字符
 转义字符: \
     转义字符后面的第一个字符转换成别的含义
     \t \n  \r \" \' \\
     
 '''
 ​
 ## f""
 print({18})
 ## b""
 print(b"asd")
 ​
 ​
 ​
 print("D:\\my\\a.txt")
 print(r"D:\my\a.txt")

布尔

 bool 
 True 
 False

字符串

1.字符串的基础

字符串属于不可变数据类型,不能直接修改字符串的本身,数字也属于不可变数据类型。

字符串的三种创建方式:

‘ ’

“ ”

‘’‘ ’‘’

1.三引号创建文本内容时,会自动解析换行符,控制台输出也换行

2.双引号,单引号 换行 自动加上括号,控制条输出不换行

字符串是一个可迭代对象,因此可以使用for循环来遍历,可以通过list等方法转换。可以通过下标获取字符串中的字符。

s = "待到春来九月八,我花开后百花杀"

1.字符串的索引

1.1获取每个字符

# 取出每一个字符
for i in s:
    print(i, end="")
print()

1.2 把字符串转化为列表

print(list(s))

1.3 把字符串转化为一个元组

print(tuple(s))

1.4获取指定字符

# 获取指定字符  '来'
print(s[3])
# 最后一个字符  字符串[-1]
print(s[-1])
2.字符串的切片
'''
字符串[start : end : step]
    start:开始下标。默认:0
    end : 结束下标 。默认:1
    step :截取步长
''' 
字符串切片 包头不包尾
print(s[1:8])

'''
字符串格式化:
    %s %d %f :占位符
    "{}".format(): 大括号占位符
    f"{变量}" :上述方法的简写

'''

'''
字符串是一个不可变数据类型,
所有对于字符串的修改操作,都会产生一个新的字符串
'''
2.字符串判断类型

2.1 字符串.isalnum() 至少有一个字符并且所有字符都是数字和字母构成,返回True 只要包含一个特殊字符,就返回False

s1 = "12132a单露1 "  ##汉字也是字母

2.2 字符串.isalpha() 至少有一个字符并且所有字符都是字母构成,返回True

s2 = "wwad"
print(s2.isalpha())

2.3 字符串.isdecimal() 至少有一个字符并且字符串只包含数字,则返回True

s3 = "10086d"
print(s3.isdecimal())  #False

2.4字符串.isdigit() 至少有一个字符并且字符串只包含数字,则返回True 识别unicode编码 # \u00b2为unicode的一个编

s4 = "\u00b2"
print(s4.isdigit())

2.5 ==字符串.isnumeric() 至少有一个字符并且字符串中只包含数字,则返回true ##阿拉伯数字和汉字数字

s5 = "432423贰"
print(s5.isnumeric())

2.6 字符串.istitle() 是否是一个标题化的格式 ,每个单词的首字母大写

s6 = "Hello World"
print(s6.istitle())

2.7 字符串.isspace() 如果字符串只有空格,则返回True

s7 = "   "
print(s7.isspace())

2.8 字符串.islower() 如果字符串中至少有一个区分大小写的字母 ,并且所有字母都是小写,则返回True

s8 = "ddddddd"
print(s8.islower())

2.9 字符串.isupper() 如果字符串中至少有一个区分大小的字母 并且所有字母都是大写,则返回True

s9 = "AAAA"
print(s9.isupper())
3.字符串的查找与替换
'''
@Project :code 
@File :3.字符串的查找与替换.py
@IDE :PyCharm 
@Author :至高造物主
@Date :2024/3/7 14:05 
'''
'''
    字符串.startswitch(str)
        判断字符串是否以str开头
    
    字符串.endswith(str)
        判断字符串是否以str结尾
    
    字符串.find(str,start=0,end=len())
        查找str在字符串中的下标,start和end可以确定查找范围
        找不到返回-1
        
    字符串.rfind(str,start=0,end=len())
        查找str在字符串中的下标,start和end可以确定查找范围
        只不过是从右开开始找
        如果找不到,报错
 '''
song = "thatgirlyaagirlss"
# 字符串.startswitch(str)
print(song.startswith("that"))

# 字符串.endswith(str)
print(song.endswith("away"))

##3.字符串.find(str,start=0,end=len())
# 查找str在字符串中的下标,start和end可以确定查找范围
# 找不到返回-1

##第一个字符的索引
print(song.find("girl", 4, 8))  # 4
##找不到返回-1
print(song.find("girl", 4, 7))  # -1

##4. 字符串.rfind(str,start=0,end=len())
# 查找str在字符串中的下标,start和end可以确定查找范围
# 只不过是从右开开始找
# 如果找不到,报错
# print(song.rfind("girl", 7, 14))  # 5
# print(song.rfind("girl", 0, 9))  #

##5. 字符串.replace(oldStr,newStr)
# 要将字符串中旧字符串oldStr,全部替换为新字符串newStr

s3 = "哈哈哈哈,你真有意思"
print(s3.replace("真有", "什么"))
4.字符串的大小写转换
'''
字符串的大小写转换
    字符串.lower(): 把字符串中所有大写的字母,全部转化为小写
    
    字符串.upper(): 把字符串中所有的小写字母,全部转换为大写
    
    字符串.swapcase(): 把字符串中所有大写的字母,全部转化为小写,小写的字母,全部转化为大写
    
    字符串.title(): 把字符串中每个单词的首字母大写,其他字母小写
    
    字符串.capitalize() : 只有首字母大写
    
'''

##1. 字符串.lower()
s1 = "helLo WoRld"
print(s1.lower())

##2. 字符串.upper()
print(s1.upper())

##3. 字符串.swapcase()
print(s1.swapcase())

##4. 字符串.title()
print(s1.title())

##5. 字符串.capitalize()
print(s1.capitalize())
5.字符串去掉空白字符
'''
@Project :code 
@File :5.字符串去掉空白字符.py
@IDE :PyCharm 
@Author :至高造物主
@Date :2024/3/7 14:41 
'''

'''
字符串.lstrip() : 去除左侧空白
字符串.rstrip() : 去除右侧空白
字符串.strip() : 去除两侧空白
'''

str1 = "  hello world  "
# 去除左侧
print(str1.lstrip())
# 去除右侧
print(str1.rstrip())
# 去除两侧
print(str1.strip())
6.字符串文本对齐
'''
@Project :code 
@File :6.字符串文本对齐.py
@IDE :PyCharm 
@Author :至高造物主
@Date :2024/3/7 14:45 
'''

'''
    字符串.ljust(width,sep)  : 字符串居左,一共有width宽度,其余位置用sep填充

    字符串.rjust(width,sep)  : 字符串居右,一共有width宽度,其余位置用sep填充
    字符串.center(width,sep) : 字符串居中,一共有width宽度,其余位置用sep填充
    
    ---sep 默认为" "
'''
s = "welcome"

print(s.ljust(20, "♥"))

print(s.rjust(20, "♥"))

print(s.center(20, "♥"))
7.字符串的拆分与链接
'''
'''
##1.字符串.partition(str)
# --- 将 字符串拆分为多个字符串 组成一个元祖
# ----  str之前 ,str , str后之后
s = "aaaaBBBBcccc"
##2.字符串.rpartition(str)
# --- 从后往前将 字符串拆分为多个字符串 组成一个元祖
# ----  str之前 str  str后之后
##3.字符串.split(str)
##以 str 分割 字符串为,返回结果为一个列表
s3 = "a-b-c-d-e-f"
print(s3.split("-"))
##4. 字符串.splitlines()   几乎不用
## 按照行分割: \r \n \r\n
##5. 字符串.join(序列)
# 以字符串为分隔符,将序类中的每个元素拼接成一个新的字符串,元素必须是字符串类型
li=["A","B","C"]
s5="-"
print(s5.join(li))

8.字符串常用方法的总结

'''
字符串+字符串
字符串*数字
字符串的比较
字符串.splite(str)
字符串.strip(str)
字符串.count(str)
字符串.find()
字符串1 in 字符串2
'''

查看数据类型

type()

# 查看变量值的数据类型
print(type(decimal))
、
# 浮点数
f = 3.145
print(type(f))

# 复数
c = complex(4, 5)
print(type(c))
'''
    布尔值:O.o 本质上就是整数
        True:真(非0)  False:假(0)
'''
b = True
print(type(b))

数据类型的转换

'''
数据类型转换:
    1.其他类型转整数:
        int(要转的内容)
    2.其他类型转浮点数:
       float(要转的内容)
    3..其他类型转字符串:
        str(内容)
    4.其他类型转布尔值:   
        bool()
        结论:
        0未False,非0True
        字符串有内容为True
        字符串无内容为False

其他类型转整数

向下取整

print(int(1.5))  #1

运算

print(int("10083")+3) #10086

进制转换

#进制转换 二----十
print(int("10010",2)) #18

布尔值转整数

print(int(True),int(False)) #1  0

其他类型转浮点数

浮点

#
print(float("1.25")) #1.25

运算

#
print(float("1.25")+1) #2.25

布尔转浮点

#
print(float(True),float(False))

其他类型转字符串

数字转字符串

#
print(str(10086)) #10086

其他类型转布尔值

bool()

规则:

0False,非0True

#0 为Flase
print(bool(0))

#非0 为True
print(bool(1))
print(bool(1.25))

字符串无内容为False

print(bool("")) #False

字符串有内容为True

print(bool("asd"))

运算符

算数运算符
比较运算符
逻辑运算符
三目运算符
赋值运算符

算数运算符:+ - * / % ** //

  1. +

'''
+ 
1.数值累加
2.连接符   拼接两个字符串
'''
print(1 + 2)  # 3

print("1" + "2")  # 12
  1. -

'''
# 减法
print(2 - 1)  # 1
'''

3.*

print(2 * 2)  #

# *:字符串*数字 ,将字符串重复n边
print("a" * 5)  # aaaaa

4.** 求幂

## (num1**num2) =>  num1的num2次方
print(2 ** 3)  # 2的三次方 8

5./ 求除法的结果

##1. 直接的结果  #2.5
print(5 / 2)

6.// 求除法取整的结果

##2. // 整除
print(5 // 2)  # 2

7.% 求余数

# %  求余数
print(5 % 2)

比较运算符

#  >
print(2 > 1)

###字符串的比较规则按照编码表进行比对
###ASCII  a:97  A:65  b:98
print('a' > 'b')

##  多个字母 从第一个到最后,比较如果能得到结果,直接给

print("aa" > "ac")  # False

##
# chr() ,数字通过编码表转化为字符
print(chr(98))  # b

# ord() ,将字符转化为数字
print(ord("单"))
print(ord("露"))

word = "c"

print(word.upper())

print(chr(ord(word) - 32))

== 比较对象

print(3>2>1>0) #支持连比

逻辑运算符

##3.逻辑运算符
##and:且 or :或 not:非
###  and :两端的表达式必须都为真,才会返回True
print(1 > 2 and 2 > 1)  # False
###  or  :两端的表达式只要有一个为真,就会返回True
print(1 > 2 or 2 > 1)  # True
###  not  :取反
print(not 1 > 2)  # True

### and写法 (number<10 and number>5)
### and简洁写法print(5< number <10)

逻辑运算符的特殊用法

'''
    逻辑运算符的特殊用法:
        如果两端为值,将值转化为bool根据以下规则返回对应的值。
        1.and:
            1真1假:返回假的值
            全真:返回第二个值
            全假:返回第一个值
        2.or:
            1真1假:返回真的值
            全真:返回第一个值
            全假:返回第二个值
        
'''
print(1 and 10)

'''

赋值运算符

'''
赋值运算符 : =  +=  -=  /=  %=  **=  //=
    将右边的内容赋值给左边
'''

# =
number = 10
# +=
number += 2
# -=
number -= 2

# /=  除等 正确结果
number /= 2

# **=
number **= 3  幂等

# //= 除法取整
number //= 2

####1.多变量赋同样的值
a = b = c = 3
####2.多变量赋不同的值
a1, b1, c1 = 1, 2, 3
####3.交换变量的值
n1 = 10
n2 = 20
n1, n2 = n2, n1
print(n1, n2)

三元运算符

'''
三目运算符(三元运算符)
# 值1 if 条件 值2

#### 如果条件是真,结果为值1,条件为假,结果为值2
'''

s = input("我能买这个吗?")
r = '真开心' if s == '1' else '嘤嘤嘤'
print(r)

成员运算符

in 和 not in

运算符的优先级:

####几种运算符的优先级
### 算数运算符 >  比较运算符 >  逻辑运算符 > 三目运算符 > 赋值运算符

默认函数

'''
    默认函数:
        input、print、len、max、min、sum...
'''

查看关键字

# 查看系统关键字
import keyword  #系统自动导入
print(keyword.kwlist)

查看虚拟环境(可以忽略)

conda config --show channels

*删除镜像

conda config --remove-key channels

添加虚拟环境

conda create -n 环境名 python=版本号

进入虚拟环境

conda activate 环境名

推出虚拟环境

conda deactivate

查看路径

conda env list

配置完后进行全局配置

虚拟环境

分支

# 流程控制语句

在程序的开发中,一共有三种流程控制语句:

## 顺序语句:

顺序语句就是按照顺序执行,从上到下,从右到左,依次执行。

## 分支语句:条件语句就是根据条件判断,然后执行相应的语句。

重点:条件。
if 来判断条件
else 如果当下条件不成立,执行该语句下的代码
elif:增加其他可能

循环

循环语句:循环语句就是重复执行某段代码,直到满足条件。

for 循环

for 变量 in 可迭代对象: ## in 成员运算符 循环输出特定的代码

while

while 条件: 执行的代码块

列表List

为了方便大批量的变量管理,出现了一个变量的容器,称之为列表(list)。列表中的变量称为列表的元素。

==变量是值的容器,列表是变量的容器

列表的表示方法:

1.空列表: list() 或 []

2.非空列表:[值,值,值,值]

空列表

emptyList = list()

非空列表:列表中可以储存多种数据类型的变量

nonEmptyList = [1, 2, 3, 4, "黄焖鸡"]
foodList = ["黄焖鸡", "地锅鸡", "西部来客炒鸡", "梅菜扣肉", "风味茄子"]
print(f"遍历列表:{foodList}")

列表的操作

1.列表元素的获取

通过元素索引

#   长度从0开始到列表的长度-1
#   格式: 列表名字[索引]
element=foodList[0]
# 如果列表中元素的索引大于列表的长度,则会list index out of range

负索引

从-长度到-1结束----(现在了解)

print(f"获取列表下标:{foodList[3]}")

获取列表的长度

##2.获取列表的长度
##  格式; 1.len(列表)
##        2. 列表.__len__()

print(f"获取列表长度:{len(foodList)}")
2.列表元素的增加
print("😁😁😁😁列表元素的增加😁😁😁😁")
##-----------(1)..append(元素):在列表最后,追加元素
foodList.append("大闸蟹")

print(f"1.通过append追加元素:{foodList}")
##-----------(2).. insert(下表,元素): 在指定下标,插入元素
foodList.insert(3, "麻辣小龙虾")
print(f"2.通过insert 插入元素:{foodList}")

##-----------(3)..extend(列表):列表中的所有元素,追加进来
drinkList = ["可乐", "酸奶"]
# extend
foodList.extend(drinkList)
print(f"3.extend追加:{foodList}")

##------------(4).. 列表 + 列表 :两个列表合并成一个新列表
li1 = [1, 3, 4]
li2 = [5, 6]
print(f"4.合并新列表:{li1 + li2}")

##------------(5). 列表 * 数字 :将该列表重复多少遍,生成新列表
newLi = li1 * 3
print(f"5.重复原列表生成一个新列表:{newLi}")
3.列表元素的删除
delList = [1, 2, 3, 4, 5, 6]
print("😁😁😁😁列表元素的删除😁😁😁😁")
##-----------1. 列表.remove(元素):删除列表中的指定元素,没有该元素,会报错
delList.remove(2)
print(f"1.remove删除指定元素:{delList}")

##-----------2. 列表.pop():  删除列表的最后一个元素,返回值为该元素
item = delList.pop()
print(f"2.pop删除最后一个元素,pop()返回值为列表的最后一个元素,该元素为:{item}")

##-----------3. pop(索引):  删除该下标的元素,并返回该下标所对应的元素
pops = delList.pop(1)
print(f"3.pop删除指定下标下的元素并返回:{pops}")

##-----------4. del 列表(下标): 删除列表制定下标的元素 (了解) 删除该下标的元素,不返回


##-----------5. clear() 清空列表
delList.clear()
print(f"4.清空列表:{delList}")
li = ["a", "b", "c"]
print(f"元素列表:{li}")
##----------列表[下标]=值
li[1] = "钞票"
print(f"修改元素:{li}")
4.查询列表元素

判断查找

coltheslist = ["外套", "卫衣", "裤子", "T衫", "卫衣", "短裤"]

  1. 列表.index(元素):查找元素在这个列表的下标

ins = coltheslist.index("裤子")
print(ins)

输出

2


  1. 列表.count(元素) ;查找这个元素在列表中出现的次数

counts = coltheslist.count("卫衣")
print(f"2. 查找这个元素在列表中出现的次数{counts}")

输出

2


  1. 元素 in 列表: 元素在不在这个列表中 返回 True False

isExitInList = "卫衣" in coltheslist
print(f"3. 元素 in 列表: 元素在不在这个列表中:{isExitInList}")

True

  1. 元素 not in 列表: 元素是否不在这个列表中 返回 True False

isNotExitInList = "卫衣" not in coltheslist
print(f"4 元素 not in 列表: 元素在不在这个列表中:{isNotExitInList}")
5.实用操作
####   实用操作:
numList = [12, 21, 53, 3, 65, 43, 21, 16]
###1.列表.reverse(): 翻转列表
print(numList.reverse())

###2.  列表的排序: 列表.sort()  正序排序
print(numList.sort())

###3.列表.copy(): 生成一个该列表的浅拷贝样本

copyList = numList.copy()
print(copyList)
6.浅拷贝
####浅拷贝
##只复制第一层列表,列表中有嵌套,不会复制嵌套列表
##副本列表,再修改嵌套列表元素的时候,原列表也会修改
li1 = ['a', [1, 2]]
c1 = li1.copy()
c1[1][0] = 3
c1[0] = "c"
print(li1)
print(c1)
7.深拷贝
import copy

li2 = ['a', [1, 2]]
c2 = copy.deepcopy(li2)
c2[1][0]=3
c2[0]="c"
print(li2)
print(c2)
8.列表元素的遍历
li = ["🥁", "😈", "👼", "🦖", "🐕"]

1.普通遍历

###1. 普通的遍历
# '''
#  for i in 可迭代对象
# '''
for i in li:
    print(i, end=" ")
print(" ")

2.for循环遍历下标

#####2.1正序遍历
for i in range(len(li)):
    print(li[i], end=" ")
print(" ")

###2.2倒序遍历
for i in range(len(li)-1, -1, -1):
    print(li[i], end=" ")
9.列表的切片
'''
列表切片:截取列表的一部分生成一个新的列表
列表[start:end:step]
start :开始下标  默认0
end    : 结束下标  默认-1
step   :截取的步长,1
# 包含开始下标,不包含结束下标
'''
nameName = ["张三丰", "张无忌", "赵敏", "黄蓉", "黄药师", "梅超风", "小龙女"]

####截取前三个元素
print(nameName[0:3])

###从下表0开始截取到5,步长为2
print(nameName[0:5:2])

###从3开始切,切到最后
print(nameName[3:])

##翻转列表
print(nameName[::-1])

li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

# 要把列表中的4到8项,翻转过来
# [1,2,3,4,9,8,7,6,5,0]

start = li[:4]
middle = li[4:9][::-1]
end = li[9:]
print(start + middle + end)
10.列表的比较

列表的比较可以用operate中的eq方法

a=[1,2]

b=[2,3]

c=[2,3]

operate.eq(list,list) 用于比较第一个列表是否等于第二个列表

输出

False

True

列表总结

Python包含以下函数:

序号函数
1len(list) 列表元素个数
2max(list) 返回列表元素最大值
3min(list) 返回列表元素最小值
4list(seq) 将元组转换为列表

Python包含以下方法:

序号方法
1list.append(obj) 在列表末尾添加新的对象
2list.count(obj) 统计某个元素在列表中出现的次数
3list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
4list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5list.insert(index, obj) 将对象插入列表
6list.pop(index=-1) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
7list.remove(obj) 移除列表中某个值的第一个匹配项
8list.reverse() 反向列表中元素
9list.sort( key=None, reverse=False) 对原列表进行排序
10list.clear() 清空列表
11list.copy() 复制列表

列表的高级用法

列表切片

'''
列表切片:截取列表的一部分生成一个新的列表
列表[start:end:step]
 start :开始下标  默认0
 end    : 结束下标  默认-1
 step   :截取的步长,1
  # 包含开始下标,不包含结束下标
'''
nameName = ["张三丰", "张无忌", "赵敏", "黄蓉", "黄药师", "梅超风", "小龙女"]
####截取前三个元素
print(nameName[:3])
###从下表0开始截取到5,步长为2
print(nameName[0:5:2])
###从3开始切,切到最后
print(nameName[3:])
##翻转列表
print(nameName[::-1])

列表推导式

[返回值 for i in list ]

列表内存

浅拷贝

元组(tuple)

元组(tuple)和列表相似:有序可重复 元组一旦生成,不可修改(第一层不可改)

元组的格式

元组的格式: 空元组

tuple() 或 ()

非空元组

t = (1, 2, 3, 4, 5, 3, 5)

元组元素的操作

1.1获取元素

print(t[0])

1.2如果元组中只有一个元素,需要在元素后加逗号

###不加逗号 括号表示优先运算,此时表示的是一个整数
t2 = (1,)
type(t2)  ######<class 'int'>

1.3元组中元素的类型可以不相同

t3 = (1, 2, [1, 2, 3])

元组中的第一层无法修改,但是如果元组中嵌套了别的可变容器,那么这个可变容器中的元素可以修改

t3[2][1] = 100
print(t3)  # (1, 2, [1, 100, 3])

元组不可改变,但可以进行切片

因为切片返回的是一个新的元组,原来的元组不会改变,不可变数据类型有 int float str tuple

t4 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
###元组的切片操作跟列表的切片操作一样
t4[0:3]  # 切 取前3个元素
print(t4[0:3])  # (1,2,3)

元组的解构

#####1.5
t5 = ("abc", "bcd", "ddl")

解构赋值 元组有多少个元素,变量就多少个

a, b, c = t5
print(a, b, c)  # abc bcd ddl

解构赋值 可以忽略某些元素' _' 但其实是是赋值一个值,所以不会报错

## 
a1, _, c1 = t5
print(a1, c1)

元组和列表的区别

元组和列表的区别: 1.元组一旦创建是不可变的,列表是可变的 2.元组没有添加,删除,修改的方法 3.del也无法删除元组中的元素 4.tuple()可以将序列表变为元组 5.list也可以将序列变为列表 元组的优点: 1.元组的速度更快 2.元组对于数据更加安全 3.元组是不可变数据类型 元组的缺点: 不能变

集合(无序不可重复)

集合(set)是一个无序的不重复元素序列。集合中的元素不会重复,并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合,元素之间用逗号 , 分隔, 或者也可以使用set() 函数创建集合。

集合的操作:

1.集合的创建
s = {1, "11", "12", 4}
print(s)
print(type(s))  -----<class 'set'>
2.集合元素的操作

2.1集合添加元素

s.add("56")

2.2添加多个

集合.update(): 可以添加一个或多个元素。

s.update(["aa", "da", "das", "sdad", "das"])
print(s)

注意:1.集合添加元素是按照一个一个字添加的。

           2.update() ()内可以添加要追加的集合或列表。

2.3移除元素

集合.remove(元素)

##1.集合.remove(元素) remove移除找不到的元素会报错
##2.集合.discard(元素): 如果元素不存在,不会报错
s1 = {"小乔", "兰陵王", "百里守约", "女娲", "西施", "王昭君"}
print(s1)
##1.集合.remove(元素)

集合.discard(元素)

s1.remove("百里守约")
print(s1)
##2.集合.discard(元素)
s1.discard("兰陵王")
print(s1)

2.4集合耳朵运算

集合运算: 交集: & 两个集合的公共元素 并集: | 两个集合的非公共元素 差集: - 获得运算符左侧的集合的独有元素 对称差集: ^ 获得公共元素外的其他元素

s3 = {"a", "b", "c", "d"}
s4 = {"a", "b", "e", "f"}
##交集:两个集合的公共元素
print(s3 & s4)  # {"a","b"}
##并集:两个集合的非公共元素
print(s3 | s4)  # {"a","b","c","d","e","f"}
##差集:获得运算符左侧的集合的独有元素
print(s3 - s4)  # {"c","d"}
##对称差集:获得公共元素外的其他元素
print(s3 ^ s4)  # {"c","d","e","f"}

集合与其他元素的相互转化

使用set可以将元素或列表或者字符串转化为集合,去除重复元素,前提是对元素顺序没有要求 。

t4 = [1, 1, 1, 2, 2, 3, 3, 3, 4, 9]
s = list(set(t4))
print(s)---[1,2,3,4,9]

注意:

1.集合中只能存储数字,字符串,元组,布尔等不可变数据类型 ​ 2.集合用大括号表示 {} 但是如果集合中没有元素,只能用set(),创建一个空集合 ​ 因为{}表示一个字典,因此空集合用set() ​ 3. '''

冰冻集合

'''
    冰冻集合: frozenset()
    跟普通的集合相比,不能修改。冰冻集合不可变数据类型
'''

字典(无序可重复)

字典是另一种可变容器模型,且可存储任意类型对象。字典是双列集合: dicrionary(dict)字典中的每一个元素,由两个数组成,称之为键值对key:value键(key):必须是不可变数据类型值(key):数据类型随意。

字典的操作

1.创建一个空字典

###创建一个空字典 :{} 或 dict()

2.字典的创建

d = {
    "姓名": "g光头",
    "性别": "男",
    "年龄": 18,
    "爱好": ["唱", "跳", "rap", "篮球", "足球", "篮球"]
}

3.字典键值的增加

字典的增加与删除
    ##如果键不存在,则会添加
    ##如果键已存在,则会覆盖

3.1 字典名[键] = 值

d["salary"] = 18888

3.2 字典.update(字典2)

字典2中所有的键值对会添加到字典1中

d2={"height":"198","city":"郑州"}
d.update(d2)

4.字典键值的修改

字典名[要修改的键]=要修改的值

d["salary"] = 20000

5.字典删除数据

5.1 字典.pop(key)

pop会移除对应的键值对,返回结果为value

ageNum = d.pop("年龄")
print(ageNum)

5.2 字典.popitem()

==popitem()移除字典中最后添加的键值对,然后把删除的键值对做成元组返回==
print(d.popitem())
==可以通过元组的解构来获取删除的key和value==
key, value = d.popitem()
print(key,value)
  1. 清空

# d.clear()
# print(len(d)) ---{}

7.查找字典中的元素

字典.get(key) :返回key对应的值

value1 = d.get("salary")

字典[key]也可以获取可以对应的值,如果key不存在,

value2 = d[年龄]

key in 字典 查找字典中是否有key

key not in 字典 查找字典中是否没有key

获取键值 键 值

##5.  字典.keys()  返回字典中所有的键组成的列表    []
print(d.keys())

##6.  字典.values()  返回字典中所有的值组成的列表  []
# print(d.values())

##7.  字典.items()  返回字典中所有的键值对组成的列表    [(),()]
# print(d.items())

字典的遍历

dictOne = {"a": 1, "b": 2, "c": 3}

1.循环键

for i in dictOne:
    print(i, dictOne[i])

2.循环键

###2. 第二种: 循环键
for i in dictOne.keys():
    print(i, dictOne[i])

3.通过元组的解构

for key, value in dictOne.items():
    print(key, value)

总结:

组合数据类型的转换:

 其他转字典: dict()
 元组-->字典 : (a,b)-->{a:b}
 列表-->字典 : [(a,b),(c,d)]-->{a:b,c:d}
 集合-->字典 : 可以但是键和值的顺序可能会反
  • 23
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值