python基础

1.数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Set（集合）

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

1.1 Number（数字）

数据类型不允许改变，如果改变数字数据类型的值，将重新分配内存空间
Python3 支持 int、float、bool、complex（复数）

四种基本类型：

类型	说明
int (整数)	整数类型只有一种 int，例如2
bool (布尔)	是 int 的子类，True 和 False 可以和数字相加
float (浮点数)	如 1.23
complex (复数)	由实部和虚部构成，可以用a + bj

x = 5    # int
y = 3.8  # float
z = 6j   # complex
j = True #bool
---------------------------
print(type(x))
print(type(y))
print(type(z))
print(type(j))

数据类型的转换:

函数名	作用
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
complex(x)	将x转换为一个复数，实数部分为 x，虚数部分为 0
complex(x, y)	将 x 和 y 转换为一个复数，实数部分为 x，虚数部分为 y 。x 和 y 是数字表达式

x = int(2.8) # x trun to 2
y = float("3")   # y trun to 3.0
z = str(3.0)  # z trun to '3.0'

数值运算：

符号	说明
+	加
-	减
*	乘
/	除法，得到一个浮点数
//	除法，得到一个整数
%	取余
**	乘方

print(1 / 3)
print(1 // 3)
print(1 // 3.0)
print(1 % 3)
print(1 ** 3)

"""
输出结果：
0.3333333333333333
0
0.0
1
1
"""

1.2 String（字符串）

python中的字符串用单引号或双引号引起来，转义时使用转义字符\或者r' ' 表示
+ 是字符串的连接符， *表示复制当前字符串，数字为复制的次数

字符串格式：

str = "hello"
# 遍历字符串：
for i in str:
    print(i, end=" ")
# 计算字符串长度，使用len()函数
print(len(str))
# 检查是否在字符串中，可用关键字in 不在可以用not in
print("l" in str)

字符串切片：

# 表达方式：str[start : end : step] 包含左边，不包含右边
# 其中start表示起始位置，end表示结束位置，step表示步长

a = "Hello"
# 从起始位置切片 hel
print(a[:3])
# 切到结尾 lo
print(a[3:])
# 负索引，从结尾开始计算，取-3位置到最后的位置 llo
print(a[-3:])

字符串格式化：

方法	说明
+	将字符串进行拼接，只能字符串与字符串拼接，数字不支持与字符串拼接
format()	将字符串和数字结合，使用占位符{}
%s、%d、%f	%s，表示一个字符串。%d，表示一个整数 。%f ，表示一个浮点数

# +拼接
age = "27"
txt = "My name is xiaohong, I am " + age
print(txt)
# format格式化
age = 27
txt = "My name is xiaohong, and I am {}"
print(txt.format(age))

# %s、%d格式化
print("I'm %s. I'm %d year old" % ('xiaohong', 27))

字符串修改：

方法	说明
upper()	所有的字符转成大写
lower()	所有的字符转成小写
strip()	去除字符串左右两侧指定字符或字符串
replace()	字符串替换str.replace(old, new)
split()	字符串分割，将字符串以指定的分隔符分割为列表[ ]
title（）	字符串中单词的首字符大写
find()	查找子串在字符串中首次出现的位置，如果未找到，返回-1
count()	统计子串在字符串中出现的次数
join()	将列表、元祖、集合中所有的元素按指定的分隔符拼接成一个字符串
title（）	字符串中单词的首字符大写
endswith（）	string.endswith(value, start, end),以什么结尾
startswith（）	string.startswith(value, start, end),以什么开始

注意：所有字符串方法都返回新值，它们不会更改原始字符串

a = "Hello "
print(a.upper())
print(a.lower())
print(a.strip())
print(a.replace("H", "h"))
print(a.split(" "))
print(a.title())

1.3 List（列表）

列表中元素的类型可以不相同，它支持数字，字符串、列表（所谓嵌套）
列表是写在方括号 [ ] 之间、用逗号分隔开的元素列表，列表项是有序的，可修改的，并允许重复的

列表语法格式：

• 列表名=[值1，值2]

列表索引语法格式如下：

• 变量[开始索引:结束索引：步长]
• 注意：索引从0开始计算，截取部分：含头不含尾，即结束索引的值不取

列表遍历：

# 遍历list列表的元素，使用for循环
for i in lists:
    print(i)

列表方法：

方法	说明
.append(元素)	列表末尾追加一个元素
.extend([元素1,元素2])	列表末尾追加多个元素
.insert(下标，元素)	向指定下标位置插入元素
.pop(下标)	移除指定下标元素，未指定默认删除最后一个元素
.remove(元素)	删除指定元素
.clear()	清空list列表
.index(元素)	获取指定元素在列表中第一次出现的下标
.count(元素)	统计元素在列表中出现的次数
.reverse()	反转列表
.sort()	排序，默认升序，降序：reverse=True

列表函数：

函数	说明
len()	计算列表长度，例：len(列表)
max()	计算列表最大元素，例：max(列表)
min()	计算列表最小元素，例：min(列表)

列表运算：

运算	说明
+	将列表进行拼接，相加
*	列表复制
in	判断元素是否在列表中
not in	判断元素是否不在列表中

操作列表元素：

# + 添加列表元素
list1+list2
# append()，末尾追加一个元素
list.append(元素)
# extend(),末尾添加多个元素
list.extend（[元素1，元素2]）
# insert(),指定位置插入
list.insert(指定位置，元素)

# 删除单个列表元素
del 列表[下标]
# 删除多个列表元素
del 列表[开始索引，结束索引]

# 修改单个列表元素
列表[下标]=新值
# 修改多个元素（通过切片）：
列表[起始位置：结束位置]=[新值1，新值2]

# 获取单个列表元素
列表[下标]
# 获取多个值
列表[起始位置：结束位置：步长]

1.4 Tuple（元组）

元组有序的，不可更改的
元组写在小括号 () 里，元素之间用逗号隔开

# 元组格式：
# 元组名=（值1，值2）

a = (1,2,3)
b = ()    # 空元组
c = (1,)  # 一个元素，需要在元素后添加逗号来表示是元组

注意：元组不能添加、删除、修改元素

# 遍历元组：
tuple = ("apple", "banana", "cherry")
for i in tuple:
  print(i)

# 拼接元组,使用+运算符
tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)
tuple3 = tuple1 + tuple2
print(tuple3)

# 使用*运算符
fruits = ("apple", "banana", "cherry")
tuple = fruits * 2
print(tuple)

输出元组：
a = (1,2,3)
b = ("hi","hello")
print (a)             # 输出完整元组
print (a[0])          # 输出元组的第一个元素
print (a[1:3])        # 输出从第二个元素开始到第三个元素
print (a[2:])         # 输出从第三个元素开始的所有元素
print (a * 2)         # 输出两次元组
print (a+ b)          # 连接元组

函数	说明
len( )	计算元组长度
type( )	查看类型

方法	说明
.count( )	计算元组元素出现次数
.index（ )	元组中元素出现次数

1.5 Dictionary（字典）

字典是无序的，用 { } 标识，是键(key) : 值(value) 的集合，键必须是不可变类型，在一个字典中，键是唯一的（列表是有序的）

新建字典：

'''使用{}创建字典'''
dict1 =	{
  "name": "盘盘",
  "mobile": "13700000000",
  "age": 18
}
print(dict1 )
print(type(dict1 ))
 
'''第二种创建dict()'''
dict1 = dict(name='盘盘', age=18)
print(dict1)
​
'''空字典'''
d1 = {}
print(d1)


# 新增键的值：
dict["hobby"]="yoga"

# 删除键的值：
del dict['盘盘']  # 删除指定的key-value
dict.clear()     # 清空字典的元素

# 修改键的值：
dict["name"]="盘盘2"

# 获取键的值：
# 获取name的值，结果应为：盘盘
# 方法一：
dict["name"]
# 方法二：
dict.get("name")

# 遍历字典：
for i in dict:
  #输出键
  print(i)
  #输出值
  print(dict[i])

# 遍历字典的值：
for i in dict.values():
  print(i)

# 遍历字典键值：
for x, y in dict.items():
  print(x, y)

字典方法：

方法	描述
clear()	删除字典中的所有元素
copy()	返回字典的副本
get()	返回指定键的值
items()	返回包含每个键值对的元组的列表
keys()	返回包含字典键的列表
pop()	删除拥有指定键的元素
popitem()	删除最后插入的键值对
update()	使用指定的键值对字典进行更新
values()	返回字典中所有值的列表
len()	字典长度

字典的特点:

• 字典中的元素是无序的
• 字典中的所有元素都是一个 key-value对，key不允许重复，value可以重复
• 字典中的key必须是不可变对象

1.6 Set（集合）

创建set集合，使用{ }
多个值之间用，隔开

集合创建格式：

# 集合名={值1，值2}
s = {1,4}

遍历集合：
set = {"盘盘", "盘盘1", "盘盘2"}
for i in set:
  print(i)

集合方法：

方法	说明
.add()	添加元素
.pop()	随机删除元素
.remove(元素)	删除指定元素
.clear()	清空集合
.update()	更新集合

集合示例：

"""
set集合（无序）：{}
不能使用和下标有关的操作
"""
names = {"盘盘", "盘盘1", "盘盘2"}
names.add("盘盘3")  # 添加元素
names.pop()  # 随机删除元素
names.remove("盘盘")  # 删除指定元素
names.clear()  #清空set集合
print(names)