系列文章：
数据类型
1.数字类型：
- int 整形 整数
- float 浮点型 小数
- complex 复数
a
+
b
j
a+bj
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))
import math
print(math.exp(1))
print(math.log(2))
print(math.sqrt(4))
import numpy as np
a = [1, 2, 3, 4, 5]
print(np.mean(a))
print(np.median(a))
print(np.std(a))
字符串类型及操作
字符串是用"" 或者’’ 括起来的任意字符
字符串中有单双引号的情况
print("I'm 18")
print('"Python" is 666')
print("\"Python\" is 666",'\'PYTHON is 777\'')
字符串切片正向
变量名[开始位置：结束位置：切片间隔]
切片间隔默认1，切片范围不包含结束位置
s = "Python"
print(s[0:3:1])
print(s[0:3])
print(s[0:3:2])
字符串切片反向
起始位置默认-1，结束位置默取到第一个位置
s = "123456789"
print(s[-1:-10:-1])
print(s[-10:-1:1])
print(s[-1:-10:-2])
print(s[:-10:-1])
print(s[-1::-1])
字符串操作符
- 字符串拼接：字符串1 + 字符串2
- 字符串成倍复制： 字符串* n 或者 n* 字符串
a = "I love "
b = "my wife "
print(a*3)
print(3*b)
成员运算 in
- 子集in全集：任何一个
连续的切片都是原来字符串的子集
folk_singers = "Peter, Paul and Mary"
"Peter" in folk_singers
for s in "Python":
print(s)
字符串处理
- 字符串分割 split(分割符号)
- 聚合字符 “聚合字符”.join(可迭代数据类型)
可迭代的数据类型：字符串、列表
字符串的示例：
s = "12345"
s_join = "*".join(s)
print(s_join)
列表的示例：列表中的元素类型必须是字符类型
例如当是数字类型会： TypeError: sequence item 0: expected str instance, int found
s = ["1", "2", "3", "4", "5"]
print("*".join(s))
- 删除两端特定字符: 字符串.strip(删除字符)
s = " I have many blanks "
print(s.strip(" "))
print(s.lstrip(" "))
print(s.rstrip(" "))
print(s)
- 字符串统计：字符串.count(“待统计字符串”)
s = "Python is an excellent language"
print(s.count("a"))
- 大写 字符串.upper()
- 小写 字符串.lower()
- 首字母大写 字符串.title()
s = "Python is an excellent language"
print(s.lower())
print(s.upper())
print(s.title())
布尔类型
整体判断真假
print(any([True,False,False]))
print(all([True,False,False]))
逐元素判断真假
import numpy as np
x = np.array([1,2,3,4,5,6])
print(x>3)
print(x[x>3])
类型转换
age = 20
name = "Py"
print(type(age))
print(type(name))
- isinstance(变量，预判类型) 变量时预判类型的子类则为真，否则为假
print(isinstance(age,int))
print(isinstance(name,str))
print(isinstance(name,object))
- 字符串.isdigit() 字符是否只有数字组成
- 字符串.isalpha() 字符串是否只有字母组成
- 字符串.isalnum() 字符串是否只有字母和数字组成
print("46sd".isdigit())
print("ss".isalpha())
print("saff6".isalnum())
- 数字类型转换为字符串 str(数字类型)
- 仅有数字组成的字符串转换为int() float() eval()
s1 = "20"
s2 = "10.1"
print(int(s1))
print(float(s1))
print(float(s2))
print(eval(s1))
print(eval(s2))
组合类型：列表、元组、字典、集合
列表
列表 list 序列类型，数据有位置顺序，支持修改元素，表示方式 ：[data1,data2]
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)))
- 列表长度len(列表)
- 列表索引，分为正向和反向
- 列表切片，正向和反向
正向切片： 变量名[开始位置:结束位置:切片间隔]
cars = ["0", "1", "2", "3"]
print(cars[:])
print(cars[:3])
print(cars[0:])
print(cars[0:3])
print(cars[:3:1])
print(cars[0:3:1])
反向切片
cars = ["0", "1", "2", "3"]
print(cars[-3:])
print(cars[:-1])
print(cars[-3:-1])
print(cars[-3::1])
print(cars[:-3:-1])
print(cars[-1:-3:-1])
列表拼接
- 用?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)
languages = ["Python", "C++", "R"]
languages.append(["Ruby", "PHP"])
print(languages)
languages = ["Python", "C++", "R"]
languages.extend(["Ruby", "PHP"])
print(languages)
- 在任意位置插入元素——列表.insert(位置编号，待增元素)
在位置编号相应元素前插入待增元素
languages = ["Python", "C++", "R"]
languages.insert(0,"Java")
print(languages)
删除元素
- 删除列表i位置的元素 ?列表.pop(位置)，默认最后一个元素
- 删除列表中的第一次出现的待删元素?列表.remove(待删元素)
languages = ["Python", "C++", "R", "Python"]
languages.pop(1)
languages.remove("Python")
print(languages)
查找元素
- 列表中第一次出现待查元素的位置?列表.index(待查元素)
languages = ['Python', 'C', 'R','Java']
idx = languages.index("R")
print(idx)
修改元素
- 通过"先索引后赋值"的方式，对元素进行修改?列表名[位置]=新值
languages[1] = “C++”
列表复制
languages = ['Python', 'C', 'R','Java']
languages_2 = languages
languages.pop()
print(languages_2)
languages_2 = languages.copy()
languages_2 = languages[:]
列表的排序
- 使用列表.sort()对列表进行永久排序，使用sorted(列表)对列表进行临时排序
- 使用sorted(列表)对列表进行临时排序，原列表保持不变，返回排序后的列表
ls = [2, 5, 2, 8, 19, 3, 7]
ls.sort()
print(ls)
ls.sort(reverse=True)
ls = [2, 5, 2, 8, 19, 3, 7]
ls2 = sorted(ls,reverse=True)
print(ls)
print(ls2)
列表翻转
- 使用列表.reverse()对列表进行永久翻转
- 直接在列表上进行操作，无返回值
ls = [1, 2, 3, 4, 5]
print(ls)
print(ls[::-1])
ls = [1, 2, 3, 4, 5]
ls.reverse()
print(ls)
for循环遍历列表
s = [1, 2, 3, 4, 5]
for i in ls:
print(i)
元组
元组 tuple 序列类型，元素有数据位置，不支持修改（增删改）元素，表示方式：(data1,data2)，通俗的讲，可以将元组视作“不可变的列表”
元组的操作
- 不支持元素增加、元素删除、元素修改操作
- 其他操作与列表的操作完全一致
b = (1, 2, 3, 4, 5)
b[0]
元组的常见用处
- 打包与解包
def f1(x):
return x**2, x**3
print(f1(3))
print(type(f1(3)))
a ,b = f1(3)
print(a,b)
numbers = [201901, 201902, 201903]
names = ["小明", "小红", "小强"]
list1 = list(zip(numbers, names))
print(list1)
for number, name in zip(numbers,names):
print(number,name)
字典
- 字典 dict 映射类型：通过“键值对”映射实现数据存储和查找，常规的字典是无序的
- 表示方式：{key1:value1, key2:value2,…}
- 字典的键必须是不可变类型，如果键是可变的就找不到对应的存储值了
- 不可变类型：数字、字符串、元组
- 可变类型：列表、字典、集合。一旦确定，还可以随意增删改
d1 = {1: 3}
d2 = {"s": 3}
d3 = {(1,2,3): 3}
d = {{1:2}: 3}
d = {[1, 2]: 3}
d = {{1, 2}: 3}
增加键值对
删除键值对
- 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())
print(students.values())
print(type(students.values()))
d.items()方法及字典的遍历
students = {201901: '小明', 201902: '小红', 201903: '小强', 201904: '小强'}
print(students.items())
for k, v in students.items():
print(k, v)
集合
集合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 Car():
"""对该类的简单介绍"""
pass
"""类后空两行"""
class Car():
"""模拟汽车"""
def __init__(self, brand, model, year):
"""初始化汽车属性"""
self.brand = brand
self.model = model
self.year = year
self.mileage = 0
def get_main_information(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))
print("PI={0},E={1}".format(PI,E))
print("PI={1},E={0}".format(PI,E))
print("{:_^16}".format(3.1415926))
print("{:*>16}".format(3.1415926))
print("{0:,}".format(10000000))
print("{0:&>20,}".format(10000000))
print("{:.2f}".format(PI))
print("{:.1%}".format(0.8888))
print("{:.2e}".format(0.888))
print("{0:b},{0:o},{0:d},{0:x}".format(450))
Python之format用法详解
|