Python数据类型&变量命名&format&集合等

---

系列文章：

---

---

数据类型

1.数字类型：

• int 整形 整数
• float 浮点型 小数
• complex 复数 $a+bj$
• 字符串类型
  由 数字、字母、空格、其他字符组合，使用’’ 或者""
  如 “asnf dslgh _ $”
• 布尔类型 bool 主要用于逻辑运算
  y = 2 < 1 # False
  / 除法的运算结果是浮点数
  // 是整数商

数字运算操作

• pow(x,n) 幂次方
• round(x,n) 四舍五入，保留小数n位
• divmod(x,y) 返回整数商和模运算的二元组
• 序列的最大值max() /最小值min()
• 求和 sum(x)

print(max(1,2,3,4,5,6))
a = [3,6,9]
print("max ",max(a))
print("min ",min(a))
print("sum ",sum(a))

• 借助科学运算库math\scipt\numpy

import math
print(math.exp(1)) #指数运算 e^1 2.718281828459045
print(math.log(2)) #对数运算 0.6931471805599453
print(math.sqrt(4)) #开平方运算 2.0

import numpy as np
a = [1, 2, 3, 4, 5]
print(np.mean(a)) #均值 3.0
print(np.median(a)) #中位数 3.0
print(np.std(a)) #标准差 1.4142135623730951

字符串类型及操作

字符串是用"" 或者’’ 括起来的任意字符
字符串中有单双引号的情况

• 双中有单

print("I'm 18") # I'm 18

• 单中有双

print('"Python" is 666') # "Python" is 666

• 双中有双，单中有单

print("\"Python\" is 666",'\'PYTHON is 777\'')

字符串切片正向

变量名[开始位置：结束位置：切片间隔]
切片间隔默认1，切片范围不包含结束位置

s = "Python"
print(s[0:3:1]) #Pyt
print(s[0:3]) #Pyt
print(s[0:3:2]) #Pt

字符串切片反向

起始位置默认-1，结束位置默取到第一个位置

s = "123456789"
print(s[-1:-10:-1]) #987654321
print(s[-10:-1:1]) #12345678
print(s[-1:-10:-2]) #97531
print(s[:-10:-1]) #987654321
print(s[-1::-1]) #987654321

字符串操作符

• 字符串拼接：字符串1 + 字符串2
• 字符串成倍复制： 字符串* n 或者 n* 字符串

a = "I love "
b = "my wife "
print(a*3) #I love I love I love
print(3*b) #my wife my wife my wife 

成员运算 in

• 子集in全集：任何一个连续的切片都是原来字符串的子集

folk_singers = "Peter, Paul and Mary"    
"Peter" in folk_singers

• 遍历字符串字符：for 字符 in 字符串

for s in "Python":
    print(s)

字符串处理

• 字符串分割 split(分割符号)
• 聚合字符 “聚合字符”.join(可迭代数据类型)
  可迭代的数据类型：字符串、列表
  字符串的示例：

s = "12345"
s_join = "*".join(s)
print(s_join) #s = ["1", "2", "3", "4", "5"]

列表的示例：列表中的元素类型必须是字符类型
例如当是数字类型会： TypeError: sequence item 0: expected str instance, int found

# s = [1,2,3] TypeError: sequence item 0: expected str instance, int found
s = ["1", "2", "3", "4", "5"]
print("*".join(s)) #s = ["1", "2", "3", "4", "5"]

• 删除两端特定字符: 字符串.strip(删除字符)

s = "      I have many blanks     "
print(s.strip(" "))#I have many blanks
print(s.lstrip(" "))#I have many blanks
print(s.rstrip(" "))#      I have many blanks
print(s)#      I have many blanks

• 字符串统计：字符串.count(“待统计字符串”)

s = "Python is an excellent language"
print(s.count("a")) #3

• 大写 字符串.upper()
• 小写 字符串.lower()
• 首字母大写 字符串.title()

s = "Python is an excellent language"
print(s.lower())
print(s.upper())
print(s.title())

布尔类型

整体判断真假

• any() 一个为真就为真
• all() 全真则真

print(any([True,False,False])) #True
print(all([True,False,False])) #False

逐元素判断真假

import numpy as  np

x = np.array([1,2,3,4,5,6])
print(x>3) #[False False False  True  True  True]
print(x[x>3]) #[4 5 6]

类型转换

• type(变量)

age = 20
name = "Py"
print(type(age)) #<class 'int'>
print(type(name)) #<class 'str'>

• isinstance(变量，预判类型) 变量时预判类型的子类则为真，否则为假

print(isinstance(age,int))#True
print(isinstance(name,str))#True
print(isinstance(name,object))#True

• 字符串.isdigit() 字符是否只有数字组成
• 字符串.isalpha() 字符串是否只有字母组成
• 字符串.isalnum() 字符串是否只有字母和数字组成

print("46sd".isdigit()) #False
print("ss".isalpha()) #True
print("saff6".isalnum()) #True

• 数字类型转换为字符串 str(数字类型)
• 仅有数字组成的字符串转换为int() float() eval()

s1 = "20"
s2 = "10.1"
print(int(s1)) #20
print(float(s1)) #20.0
# print(int(s2))  报错 浮点型字符串不能直接到int
print(float(s2)) #10.1
print(eval(s1)) #20
print(eval(s2)) #10.1

组合类型：列表、元组、字典、集合

列表

列表 list 序列类型，数据有位置顺序，支持修改元素，表示方式 ：[data1,data2]

• 列表声明
  方式1

ls = ["Python", 1989, True, {"version": 3.7}]

方式二：list(可迭代对象，包含字符串、元组、集合、rang()等)

print(list("人工智能是未来的趋势")) #字符串
print(list(("我", "们", "很", "像"))) #元组
print(list({"李雷", "韩梅梅", "Jim", "Green"})) #集合

range(起始位置，结束位置，数字间隔)
起始默认0，必须包含结束位置，数字间隔默认1

for i in range(1, 11, 2):
    print(i)
print(list(range(0,11,2))) #range()

• 列表长度len(列表)
• 列表索引，分为正向和反向
• 列表切片，正向和反向

正向切片： 变量名[开始位置:结束位置:切片间隔]

cars = ["0", "1", "2", "3"]
print(cars[:]) #['0', '1', '2', '3']
print(cars[:3]) #到3结束['0', '1', '2']
print(cars[0:]) # 从0开始 ['0', '1', '2', '3']
print(cars[0:3]) #从0开始到3结束['0', '1', '2']
print(cars[:3:1])#到3结束吗，间隔为1['0', '1', '2']
print(cars[0:3:1])#['0', '1', '2']

反向切片

cars = ["0", "1", "2", "3"]
print(cars[-3:]) #['1', '2', '3']
print(cars[:-1]) #['0', '1', '2']
print(cars[-3:-1]) #['1', '2']
print(cars[-3::1]) #['1', '2', '3']
print(cars[:-3:-1]) #['1', '2', '3']
print(cars[-1:-3:-1]) #['1', '2', '3']

列表拼接

• 用 list1+lis2 的形式实现列表的拼接
• 用 n*list 或 list*n 实现列表的成倍复制

[0]*10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

列表操作
添加元素

• 在末尾增加单个元素——列表.append(待增元素)
  当待添加元素是列表时，会把这个列表当成一个元素
• 使用extend(列表)，会把这个列表中的每个元素逐个添加，相当于添加多个元素

languages = ["Python", "C++", "R"]
languages.append("Java")
print(languages) #['Python', 'C++', 'R', 'Java']

languages = ["Python", "C++", "R"]
languages.append(["Ruby", "PHP"]) 
print(languages) #['Python', 'C++', 'R', ['Ruby', 'PHP']]

languages = ["Python", "C++", "R"]
languages.extend(["Ruby", "PHP"])
print(languages) #['Python', 'C++', 'R', 'Ruby', 'PHP']

• 在任意位置插入元素——列表.insert(位置编号，待增元素)
  在位置编号相应元素前插入待增元素

languages = ["Python", "C++", "R"]
languages.insert(0,"Java")
print(languages) #['Java', 'Python', 'C++', 'R']

删除元素

• 删除列表i位置的元素  列表.pop(位置)，默认最后一个元素
• 删除列表中的第一次出现的待删元素 列表.remove(待删元素)

languages = ["Python", "C++", "R", "Python"]
languages.pop(1)
languages.remove("Python")
print(languages) #['R', 'Python']

查找元素

• 列表中第一次出现待查元素的位置 列表.index(待查元素)

languages = ['Python', 'C', 'R','Java']
idx = languages.index("R")
print(idx) #2

修改元素

• 通过"先索引后赋值"的方式，对元素进行修改 列表名[位置]=新值
  languages[1] = “C++”

列表复制

• 错误的方式
  原来的改变了，复制的也跟着改变

languages = ['Python', 'C', 'R','Java']
languages_2 = languages
languages.pop()
print(languages_2) #['Python', 'C', 'R']

• 正确的方式-浅拷贝
  • 方法1：列表.copy()
  • 方法2：列表[ : ]

languages_2 = languages.copy()
languages_2 = languages[:]

列表的排序

• 使用列表.sort()对列表进行永久排序，使用sorted(列表)对列表进行临时排序
• 使用sorted(列表)对列表进行临时排序，原列表保持不变，返回排序后的列表

ls = [2, 5, 2, 8, 19, 3, 7]
ls.sort() #默认递增
print(ls) #[2, 2, 3, 5, 7, 8, 19]
ls.sort(reverse=True) #递减排序

ls = [2, 5, 2, 8, 19, 3, 7]
ls2 = sorted(ls,reverse=True)
print(ls) #[2, 5, 2, 8, 19, 3, 7]
print(ls2) #[19, 8, 7, 5, 3, 2, 2]

列表翻转

• 使用列表.reverse()对列表进行永久翻转
• 直接在列表上进行操作，无返回值

ls = [1, 2, 3, 4, 5]
print(ls) #[1, 2, 3, 4, 5]
print(ls[::-1]) #[5, 4, 3, 2, 1]

ls = [1, 2, 3, 4, 5]
ls.reverse()
print(ls) #[5, 4, 3, 2, 1]

for循环遍历列表

s = [1, 2, 3, 4, 5]
for i in ls:
    print(i)

元组

元组 tuple 序列类型，元素有数据位置，不支持修改（增删改）元素，表示方式：(data1,data2)，通俗的讲，可以将元组视作“不可变的列表”

元组的操作

1. 不支持元素增加、元素删除、元素修改操作
2. 其他操作与列表的操作完全一致

b = (1, 2, 3, 4, 5)
b[0]

元组的常见用处

1. 打包与解包

def f1(x): #返回x的平方和立方
    return x**2, x**3 #实现打包方式返回
print(f1(3)) #(9, 27)
print(type(f1(3))) #<class 'tuple'>

#解包
a ,b = f1(3)
print(a,b) #9 27

numbers = [201901, 201902, 201903]
names = ["小明", "小红", "小强"]
list1 = list(zip(numbers, names))
print(list1)
# 每次取到一个元组，进行解包赋值
for number, name in zip(numbers,names): 
    print(number,name)
# 201901 小明
# 201902 小红
# 201903 小强

字典

• 字典 dict 映射类型：通过“键值对”映射实现数据存储和查找，常规的字典是无序的
• 表示方式：{key1:value1, key2:value2,…}
• 字典的键必须是不可变类型，如果键是可变的就找不到对应的存储值了
  • 不可变类型：数字、字符串、元组
  • 可变类型：列表、字典、集合。一旦确定，还可以随意增删改

d1 = {1: 3}
d2 = {"s": 3}
d3 = {(1,2,3): 3}

d = {{1:2}: 3}# TypeError: unhashable type: 'dict'
d = {[1, 2]: 3} #TypeError: unhashable type: 'list'
d = {{1, 2}: 3} #TypeError: unhashable type: 'set'

增加键值对

• 变量名[新键] = 新值

删除键值对

• del 变量名[待删除键]
• 变量名.pop(待删除键)
• 变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对

students = {201901: '小明', 201902: '小红', 201903: '小强'}
del students[201903]
students.pop(201901)
students.popitem()

修改值

• 通过先索引后赋值的方式对相应的值修改
  如students[201902] = “小雪”

d.get()方法
d.get(key,default) 从字典d中获取键key对应的值，如果没有这个键，则返回default

d.keys() d.values() 方法

students = {201901: '小明', 201902: '小红', 201903: '小强', 201904: '小强'}
print(students.keys()) #dict_keys([201901, 201902, 201903, 201904])
print(students.values()) #dict_values(['小明', '小红', '小强', '小强'])
print(type(students.values())) #<class 'dict_values'>

d.items()方法及字典的遍历

students = {201901: '小明', 201902: '小红', 201903: '小强', 201904: '小强'}
print(students.items())
for k, v in students.items():
    print(k, v)
# 201901 小明
# 201902 小红
# 201903 小强
# 201904 小强

集合

集合set 一系列互不相等元素的集合，是无序的,表示方式：{data1, data2}
元素必须是不可变类型：数字、字符串、元组

s = {'小明',"黄晓明","黄晓明"}
# 自动去重
print(s) #{'小明', '黄晓明'}

集合运算

• & 与
• | 或
• ^ 异或
• - 差

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
print(Chinese_A&Math_A)
print(Chinese_A | Math_A)
print(Chinese_A ^ Math_A)
print(Chinese_A - Math_A)

集合的操作方法

• 添加元素 S.add(x)
• 移除元素 S.remove(x)
• 集合的长度 len(S)
• 集合的遍历 for start in S：

S = {"刘德华", "张学友", "张曼玉"}
S.add("王祖贤")
S.remove("王祖贤")
len(S)
for start in S:
    print(start)

命名规范

变量命名

组成：字母、数字、下划线、汉字及其组合
严格区分大小写

不允许首字符为数字，变量之间不允许有空格，不能与33个Python保留字相同
推荐命名方式：变量由多个单词组成：使用_连接
采用驼峰命名

Python_is_第一名 = True
print(Python_is_第一名)

程序格式-空格的使用

• 二元运算符两边加一个空格

x = 2
x += 4
6 > 2

• 逗号后使用空格

x, y = 1, 2
ls = [1, 2, 3]

• 使用不同优先级时，在最低优先级的运算符周围添加空格

x = x*2 + 1
z = x*x + 1*2
c = (x+z) * (x+z)

• 不要使用一个以上的空格

函数命名

1、函数及其参数的命名参考变量命名

• 字母小写及下划线组合

2、应包含简要阐述函数功能的注释，注释紧跟函数定义后面

def foo():
    # 这个函数的作用是为了给大家瞅一瞅，你瞅啥，瞅你咋地。。。。
    pass

3、函数定义前后各空两行

def f1():
    pass

                 # 空出两行，以示清白

4、默认参数赋值等号两侧不需加空格

def f3(x=3):    # 默认参数赋值等号两侧不需加空格
    pass

类命名

1、类-命名规范
驼峰命名法：组成的单词首字母大写
Dog、 CreditCard、 ElectricCar

# class 类名：
"""类前空两行"""


class Car():
    """对该类的简单介绍"""
    pass

"""类后空两行"""

class Car():
    """模拟汽车"""
    
    def __init__(self, brand, model, year):
        """初始化汽车属性"""               # 相当于类内部的变量
        self.brand = brand                 # 汽车的品牌
        self.model = model                 # 汽车的型号
        self.year = year                   # 汽车出厂年份
        self.mileage = 0                   # 新车总里程初始化为0  
        
    def get_main_information(self):        # self不能省
        """获取汽车主要信息"""
        print("品牌：{}   型号：{}   出厂年份：{}".format(self.brand, self.model, self.year))
    
    def get_mileage(self):
        """获取总里程"""
        return "行车总里程：{}公里".format(self.mileage)

数据输出格式化方法 format

基本格式：“字符{0}字符{1}”.format(value1,value2)

PI = 3.1415926
E = 2.71828
print("PI={},E={}".format(PI,E)) #PI=3.1415926,E=2.71828
# 0,1是对应后面数据的位置
print("PI={0},E={1}".format(PI,E)) #PI=3.1415926,E=2.71828
print("PI={1},E={0}".format(PI,E)) #PI=2.71828,E=3.1415926

print("{:_^16}".format(3.1415926)) #___3.1415926____
# _____3.1415926______
print("{:*>16}".format(3.1415926)) #print("{:*>16}".format(3.1415926))
print("{0:,}".format(10000000)) #10,000,000
# 显示1,000,000
# &&&&&&&&&&10,000,000
print("{0:&>20,}".format(10000000))#填充左边，数字和&工20位
# 留2位小数
print("{:.2f}".format(PI)) #.xf保留小数后x位
# 按百分数输f出
print("{:.1%}".format(0.8888)) #.x%保留%后x位
# 科学计数法输出
print("{:.2e}".format(0.888)) #8.88e-01
# 二进制、unicode码、十进制、八进制、十六进制输出
print("{0:b},{0:o},{0:d},{0:x}".format(450))

Python之format用法详解