Python基础（一）

数据类型

• 计算机中是以二进制存储数据：二进制，因为计算机只识别二进制。二进制稳定性高，只有0和1；成本低，在技术上容易实现；便于解决生活中的实际问题，与生活中的真假逻辑相吻合

数据类型

• 说明：编程语言中不同的数据类型都是为了解决生活中的实际问题而出现的，每种类型都有相关的运算。python中常用数据类型：整形、浮点、布尔、字符串、列表、元组、字典、集合等，这里给大家整理一下各类数据类型，并举例

• 整型(int)：就是数学中的整数

• 浮点(float)：就是数学中的小数

b = 3.1415926
print(b, type(b))
# 科学计数法
c = 3.1415926e-3
print(c, type(c))

• 复数(complex)

d = 2 + 5j
print(d, type(d))

• 布尔(bool)：只有两个值True/False，对应于生活中的真假逻辑

• 空(NoneType)：空类型，只有一个值None

• 字符串(str)：使用引号括起来的一串字符：引号可以是一对单引号、一对双引号、三对单引号、三对双引号

• 列表(list)：通过[]进行定义，可以存放一系列的任意数据，是一种容器类型

lt = [6, 3, 'hello', 3.14, False]

print(lt, type(lt))
# 通过下标获取元素，有越界问题
print(lt[3])

• 元组(tuple)：通过()进行定义可以作为容器存放任意数据，元素是不可修改的

lt = [6, 3, 'hello', 3.14, False]
print(lt, type(lt))

tp = (1, 2, 3,[ 4, 5])
print(tp, type(tp))
# 也是通过下标进行访问
print(tp[2])

# 定义一个元素的元组后面要添加一个,（逗号）
tp2 = (1,)
print(tp2, type(tp2))

• 集合(set)：通过{}进行定义，可以作为容器存放任意数据，但是元素是不能重复的，且是无序的。

s1 = {'一', '二', '三', '四', '五', }
s2 = {'五', '六', '七'}
# 交集
print(s1 & s2)
# 并集
print(s1 | s2)
# 差集
print(s1 - s2)
print(s2 - s1)

# 定义空集合不能使用{}，这是留给定义空字典使用的，应该使用set()
s3 = {}
print(type(s3))
s4 = set()
print(type(s4))

集合经常用于去重操作

• 字典(dict)：通过{}进行定义
  • 元素是由键值对组成的
  • 键和值之间是有’:’进行连接
  • 键是唯一的，而值可以是任意
  • 示例：

d = {'name': 'lisi', 'age': 18}
print(d, type(d))
# 可以根据键获取值
print(d['name'])
# 当键不存在时或报KeyError错
# print(d['weight'])
# 可以通过get方法根据键获取值，
print(d.get('age'))
# 当键不存在时不会报错，会返回None
print(d.get('weight'))
# 可以设置默认值，有对应的键返回其值，没有时返回设置的默认值
print(d.get('weight', 75))

# 统计元素个数，字典统计的是键值对个数
print(len(d))
print(len(s1))
print(len(lt))
print(len('helloworld'))

数据类型	特点
字典	通过{}进行定义元素；是由键值对组成的键和值；之间是有’:’进行连接；键是唯一的，而值可以是任意的
集合	通过{}进行定义；可以作为容器存放任意数据；元素是不能重复的，且无序
元祖	通过()进行定义；可以作为容器存放任意数据；元素不可修改
列表	通过[]进行定义；可以存放一系列的任意数据，一种容器类型
字符串	使用引号括起来的一串字符：引号可以是一对单引号、一对双引号、三对单引号、三对双引号

类型转换

• 隐式类型转换：混合运算、条件判断

• 强制类型转换：使用专门的函数进行转换

数据类型	强制类型转换
int	转换为整型
float	转换为浮点
str	转换为字符串
list	转换为列表
tuple	转换为元组
set	转换为集合
dict	转换为字典

• 示例

# 转换为整数
# a = int(3.14)
# 参数1：需要转换的数据
# base：数据的进制类型，默认为十进制
# a = int('123', base=8)
# a = int('abc', base=16)

# 浮点
# a = float(250)

# 字符串
# a = str(123)

# 列表
# a = list('hello')
# a = list((1, 2, 3))
# a = list({1, 2, 3})
# 可以转换不会报错，但是只保留了键
# a = list({'name': 'ergou', 'age': 18})

# 元组
# a = tuple([1, 2, 3])

# 集合
# a = set([1, 2, 3])

# 字典
lt = [('name', 'dahua'), ('age', 18)]
a = dict(lt)
print(a, type(a))

类型相关操作

• 字符串

s1 = 'hello'
s2 = 'world'
# 可以使用'+'将字符串拼接在一起
s3 = s1 + s2
print(s3)

# '*'可以重复前面的字符串若干次
s4 = 'abc' * 3
print(s4)

# len函数统计字符串长度
print(len(s1))

s = 'abcdefg'
# 从开头进行提取，下标从0开始
print(s[0])
# 从末尾进行提取，下标从-1开始
print(s[-1])

# 切片
# 格式：s[开始:结束:步进]
print(s[1:3])
# 当一边的边界省略，则提取到改侧的边缘
print(s[1:])
print(s[:4])
print(s[1:-2])
print(s[:-3])
print(s[-3:])

# 指定步进值，默认为1
print(s[::2])
# 逆序提取
print(s[::-1])

# 格式化
# %s：字符串
# %d：整型
# %f：浮点
# %c：字符
name = '二狗'
like = '大花'
age = 18
print('俺叫%s,暗恋%s,她今年%d岁' % (name, like, age))

# python中特有的解决方案
print('俺叫{},暗恋{},她今年{}岁'.format(name, like, age))
print('俺叫{2},暗恋{1},她今年{0}岁'.format(name, like, age))
print('俺叫{l},暗恋{n},她今年{a}岁'.format(n=name, l=like, a=age))

• 列表

lt = [1, 2, 3, 4, 5]

print(lt[0])
print(lt[-1])
print(lt[1:3])
print(len(lt))

# 修改元素
lt[0] = 100

# 追加元素，将传递的元素作为一个整体(一个元素)追加到列表尾部
lt.append(200)
# lt.append([300, 400])
# 将可迭代对象的元素展开添加到列表中
lt.extend([300, 400])

# 插入元素，在指定位置插入元素
lt.insert(2, 250)
lt.insert(4, 250)

# 删除元素
# 根据索引号删除
del lt[0]
# 根据值进行删除，只会删除第一个
lt.remove(250)
# 返回并删除：返回并删除指定下标的元素，默认是最后一个
ele = lt.pop(2)
# print(ele)
# print(lt)

lt = [1, 2, 3, 4, 5, 3]
# 查询元组在列表中的索引号
# 找到就会返回其索引号，即第一个出现的位置
# 若不在列表中则会报错
print(lt.index(3))
# 统计元素在列表中出现的次数
print(lt.count(3))

# 逆序
lt.reverse()

# 排序
# reverse=True表示降序排序
lt.sort(reverse=True)
print(lt)

ASCLL

• 说明：美国信息交换标准代码，就是用一个数字表示一个字符的规范

• 转换函数：

# 字符 => ASCII
print(ord('A'))
# ASCII => 字符
print(chr(97))

运算符相关类型操作

• 字符串切片
• 列表操作
• 元组操作

# tp1 = (1, 2, 3)
# tp1 = (1,)
tp1 = 1, 2, 3
tp2 = (4, 5, 6)
# 可以直接拼接在一起
# tp3 = tp1 + tp2
# print(tp3, type(tp3))
# 重复指定次数
tp4 = tp1 * 3
print(tp4)
# 统计元素个数
print(len(tp4))
tp = (1, 2, 3, 4, 5, 6)
# 切片操作
print(tp[0], tp[-1])
print(tp[1:-1])
# 获取指定元素的索引
print(tp.index(3))
# 统计元素出现的次数
print(tp.count(3))
# 最大值
print(max(tp))
# 最小值
print(min(tp))

• 集合操作

s = {'一', '二', '三', '四', '五', '六'}

# 添加元素
s.add('七')

# 删除元素
# s.remove('七')
# 删除不存在元素会报KeyError错
# s.remove('八')
# 删除元素，元素存在则删除，不存在也不报错
s.discard('八')

# 返回并删除，元素是随机的
print(s.pop())

# 清空元素
s.clear()

# print(s)

s1 = {'小一', '小二', '小四'}
s2 = {'小六', '小五', '小一', '小二', '小四'}

# 并集
# print(s1.union(s2))

# 交集
# print(s1.intersection(s2))
# 求交集，并用交集覆盖原来的集合
# s1.intersection_update(s2)

# 差集
# print(s1.difference(s2))
# 求差集，并用差集覆盖原来的集合
# s1.difference_update(s2)
# print(s1)

# 判断是否没有交集
print(s1.isdisjoint(s2))
# 判断是否是另一集合的子集
print(s1.issubset(s2))
# 判断是否是另一集合的父集/超集
print(s2.issuperset(s1))

• 字典操作

d = {'name': 'lisi', 'age': 20}

# 获取元素
# 有就返回对应的值，没有就报KeyError错
print(d['name'])
# 有就返回对应的值，没有就返回None，可以指定默认值
print(d.get('namexxx', '默认值'))

# 修改元素
# 键存在则修改对应的值
d['name'] = 'lisi'
# 键不存在则添加键值对
d['height'] = 180

# 更新：存在的键会覆盖，不存在的键会添加
d.update({'name': 'zhangsan', 'weight': 50})

# 删除元素
# del d['weight']
# 返回并删除
print(d.pop('weight'))

# 清空元素
d.clear()

print(d)

流程控制

分支结构

• 说明：

  • 按照代码的执行流程，程序可以分为三种结构：顺序结构、分支结构、循环结构
  • 顺序结构：代码按照从上到下的顺序依次执行的结构，没有语法要求
  • 代码层次：python中的代码层次不是通过大括号表示的，而是通过缩进体现的

• 分支结构(if-elif-else)

• 格式1：适合于解决生活中的条件执行问题

if 表达式:
    语句块

执行流程：当程序执行到if语句时，首先会判断表达式的真假。若表达式的值为真，则执行后面缩进的语句块；若表达式的值为假，则跳过语句块，执行后面的内容。

• 格式2：适合于解决生活中的非此即彼的问题

if 表达式:
    语句块1
else:
    语句块2

执行流程：当程序执行到if-else语句时，首先会判断表达式的真假。若表达式的值为真，则执行语句块1；若表达式的值为假，则执行语句块2.

• 格式3：适合于解决生活中的多种选择问题

if 表达式1:
    语句块1
elif 表达式2:
    语句块2
...
else:
    语句块n

1、elif的个数没有限制
2、else可以省略不写
3、所有的互斥选择语句块最多只能执行一个

循环结构(while)

• 格式：

while 表达式:
    语句块

执行流程：当程序执行到while语句时，首先判断表达式的真假。若表达式的值为真，则执行缩进的语句块，之后返回表达式继续判断；若表达式的值为假，则跳过缩进的语句块执行。

• 说明：

	表达式：也叫循环条件
	语句块：也叫循环体
	死循环：循环条件一直成立
	break：跳出循环
	continue：结束本次循环，进入下次循环
	else：对应的语句块，循环正常退出时会执行，非正常退出(break)时不执行

循环结构(for-in)

• 说明：也是一种循环结构，经常用于便利可迭代对象，如：字符串、列表、元组、字典等

• 格式：

for x in y:
    语句块

执行流程：x一次代表y种的一个元素，遍历结束循环也就结束了。

列表生成式

• range：

# 一个对象，保存了产生连续整数的算法，可以节约空间
# 可以指定起始位置，默认为0
# print(range(10))

# 可以进行遍历
for i in range(10):
    print(i)

# 可以转换为列表
print(list(range(2, 10)))

• 列表生成式

# 列表生成式：可以快速方便地生成列表
print([i for i in range(1, 11)])
print([i for i in 'abcdefg'])
print([i*2 for i in range(1, 11)])
print([i*i for i in range(1, 11)])
print([str(i) for i in range(1, 11)])
print([i for i in range(1, 11) if i % 2 == 0])
# 生成的列表可以与遍历的内容没有一毛钱关系
print([250 for i in range(1, 11)])

循环嵌套

• 循环可以嵌套
• 循环嵌套示例

# 外层循环控制打印多少行
for i in range(1, 11):
    # print('*' * i)
    # 内存循环控制每一行多少个
    for j in range(i):
        print('*', end=' ')
    print()

• 例题：列表排序实现，冒泡排序法思路(升序排序)

lt = [8, 3, 6, 9, 5, 2, 4, 1, 7]
第一轮：[3, 6, 8, 5, 4, 1, 7, 9]
第二轮：[3, 6, 5, 4, 1, 7, 8, 9]
第三轮：[3, 5, 4, 1, 6, 7, 8, 9]

• 参考示例：

# 冒泡排序：升序排序
lt = [8, 3, 6, 9, 5, 2, 4, 1, 7]
n = len(lt)
# 外出循环控制排序多少轮
for i in range(n-1):
    # 内存循环控制相邻两个元素的比较
    for j in range(n-1-i):
        if lt[j] > lt[j+1]:
            # 通用交换元素方式
            # temp = lt[j]
            # lt[j] = lt[j+1]
            # lt[j+1] = temp
            # python中特有方式
            lt[j], lt[j+1] = lt[j+1], lt[j]

print(lt)

• 选择排序

思路：先取出一个位置，用该位置的元素与后面的所有元素挨个比较，不合适就发生交换。
示例：lt = [8, 3, 6, 9, 5, 2, 4, 1, 7]
    第一轮：1, 8, 6, 9, 5, 3, 4, 2, 7
    第二轮：1, 2, 8, 9, 6, 5, 4, 3, 7
    第三轮：1, 2, 3, 9, 8, 6, 5, 4, 7

字符串操作

• 切割与拼接

s = 'I love you more than i can say'
# 切割字符串
# sep：指定按照什么进行切割，默认按照空格切割
# maxsplit：指定最大切割次数，默认不限制次数
# ret = s.split(sep='abc', maxsplit=1)
# 从右边进行切割
ret = s.rsplit(' ', maxsplit=1)
print(ret)

s = 'Hello\nworld'
# 按照换行进行切割
print(s.splitlines())

s = 'I love you more than i can say'
ret = s.split()
# print(ret)
# 字符串拼接
s2 = '*'.join(ret)
print(s2)

• 查找统计判断

s = 'Hi buddy, if you have something to say, than say; if you have nothing to say, than go.'

# 子串查找：找到首次出现的位置，返回下标，找不到返回-1
# ret = s.find('hello')
# 从后面查找
# ret = s.rfind('to')
# 统计子串出现的次数
# ret = s.count('if')
# 判断是否已指定内容开头
# ret = s.startswith('Hi')
# 判断是否已指定内容结尾
ret = s.endswith('go.')
print(ret)

• 转换及替换

s = 'hellO worlD!'
# 转换为全大写
print(s.upper())
# 转换为全小写
print(s.lower())
# 大小写转换
print(s.swapcase())
# 首字母大写
print(s.capitalize())
# 每个单词首字母大写
print(s.title())
# 用指定的内容替换指定内容，还可以值替换次数
print(s.replace('l', 'L', 2))

• 类型判断

s = 'abcABC2'
# 是否是全大写
print(s.isupper())
# 是否是全小写
print(s.islower())
# 是否每个单词首字母都大写
print(s.istitle())
# 是否是全数字字符
print(s.isdecimal())
# 是否是全字母
print(s.isalpha())
# 是否全是字母或数字
print(s.isalnum())