Python 基础汇总（一） 数据类型、条件判断、循环、序列等

一：类型，类型主要有字符串，浮点数，整数，元组，集合，列表，字典等。与java区别的就是元组

       数据类型 有可变的比如 列表，还有不可变（不可以更改的）例如字符串，元组

      对比Java:  集合相当于List，列表相当于数组，字典相当于Map

# 列表
e = [10,20,30]
# 元组
f = (10,20,30)
# 集合
g = {10,20,30}

print(type(e))

print(type(g)),

# 字典
h = {"name":"张三"}
print(h)

二.格式化输出(print)

主要就是 %s , %d ,%f    还有通用格式化符号f   其中：

格式化符号

%s ：格式化输出字符串

%d ：格式化输出整数

%f ：格式化输出浮点数 

f'{ 表达式 }'

转义字符 ：

\n ：换⾏

\t ：制表符

age = 18
name = 'TOM'
weight = 75.5
student_id = 1

#我的名字是Tom
print('我的名字是%s'%name)

#我的学号是0001  %4d 作用是补0 补足四位
print('我的学号是%04d' %student_id)

# 浮点数  我的体重是75.500000
print('我的体重是%f' %weight)
#t通用格式化 f
print(f'我的学号是{student_id},我的年龄是{age + 1},我的名字是{name}')

三.输入

输入接受的都会被转成字符串

# 输入 input('提示⽂字')
name = input("请输入名字")

print(f"您的名字是{name}")

四。数据类型转换

常用的有int(),float(),str(),eval(),tuple(),list()

int（）转整形 ， str()转字符串 ，tuple()转元组，list()转列表，float()转浮点数，eval() 将字符串内的数据还原成本来的数据类型

num1 = 1
print(float(num1))  # int->float 1.0

str1 = "1"
print(int(str1))  # 1

# 序列转元组
list1 = [1,2,3]
print(tuple(list1))  # (1, 2, 3)

# 序列转列表
t1 = (1,2,3)
print(list(t1))  # [1, 2, 3]

#eval() -- 将字符串中的数据转换成Python表达式原本类型
str2 = '[1, 2, 3]'
print(eval(str2))  # [1, 2, 3]
print(type(eval(str2)))  # <class 'list'>

五.运算符

运算符 ：

算术运算符，赋值运算符，复合赋值运算，比较运算符，逻辑运算符

算数运算符：先加减后乘除，带括号先算括号

赋值：多变量赋值

num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)

复合赋值运算： a += 1 (即a= a+1)

c = 10
c += 1 + 2
# 输出13, 先算运算符右侧1 + 2 = 3， c += 3 , 推导出c = 10 + 3
print(c)

比较运算符： >,<,==,!=,>=,<=  返回布尔类型

逻辑运算符：普通逻辑运算符 and,or,not  以及数字之间的逻辑运算

                    数字键的逻辑运算：and 时，只要有一个数字是0返回就是0，否则结果为最后一个不为0的数字

                                                    or 时，只有i盎格数字同为0，结果返回0，否则返回第一个不为0的数字

a = 1
b = 2
c = 3
print((a < b) and (b < c))  # true
print((a > b) or (b < c))  # true
print(not a > b)  # true


# 特殊的 数字键的 逻辑运算
a = 0
b = 1
c = 2
# and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个⾮0数字
print(b and a)  # 0
print(b and a)  # 0
print(a and c)  # 0
print(c and a)  # 0
print(b and c)  # 2
print(c and b)  # 1
# or运算符，只有所有值为0结果才为0，否则结果为第⼀个⾮0数字
print(a or b)  # 1
print(a or c)  # 2
print(b or c)  # 1

六.条件判断语句

冒号后，缩进四个字符

if 条件 :

    条件成⽴执⾏的代码 1

    条件成⽴执⾏的代码 2

......

if 条件 1 :

    条件 1 成⽴执⾏的代码 1

    条件 1 成⽴执⾏的代码 2

    ......

elif 条件 2 ：

    条件 2 成⽴执⾏的代码 1

    条件 2 成⽴执⾏的代码 2

    ......

    ......

else :

    以上条件都不成⽴执⾏执⾏的代码

七.导入模块 

 import 

import random
a = random.randint(0,2)
print(a)

#三目运算符
b = 1
c = a if a > b else b
print(c)

 八.循环

循环分为while 循环 和 for循环

也是要注意冒号下一行缩进四个字符

i = 0
while i < 5:
	print(f"数字{i}")
	i += 1

# 计算1-100的偶数累加和
i = 0
result = 0
while i <= 100:
	if i % 2 == 0:
		result += i
	i = i+1

print(result)


str = "abcdef"
for i in str:
	print(i)

其中两个关键字，break 和 continue

break:跳出循环，执行循环后面语句

 

continue:跳出当前循环，执行下一次循环

i = 1
while i <= 5:
	if i == 3:
		print("退出循环")
		break
	print(f"执行{i}")
	i += 1
else:
	print("不执行")

# 执行1
# 执行2
# 退出循环

while循环嵌套，打印九九乘法表

j = 1
while j <= 9:
    # 打印⼀⾏⾥⾯的表达式 a * b = a*b
    i = 1
    while i <= j:
       print(f'{i}*{j}={j*i}', end='\t')
       i += 1
    print()
    j += 1

 for 循环

str1 = 'itheima'
for i in str1:
	print(i)

for循环 break 和 continue 用法 与 while 循环一样

 

九.数据序列

1)字符串，字符串不可修改

字符串定义方式有单引号，双引号，三引号，其中，三引号字符串支持换行

name = "Tom"
name2 = 'Rose'
#三引号形式的字符串⽀持换⾏
name3 = '''i am Tom ,
              nice to meet you'''
name4 = '''i am Rose ,
            nice to meet you'''

print("我是%s" %name)
#print(f'我的名字是{name}')

字符串切片，可以分割字符串，返回分割后的数据  

切片[开始下标，结束下标，步进]  注意结束下标不包含在内

# 切片 【开始位置：结束位置：步进】
a = 'abcdef'
b = a[2:5:1]
print(b)  # cde

 

 

name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 负1表示倒数第⼀个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba

 

字符串下标输出（下标从0开始）

#字符串下标
print(name[0])

字符串查找 find(),index()等

find()检测某个字串是否在这个字符串中，如果在返回所在的开始位置下标，否则返回-1

a = 'abcdefg'
# find(字串，开始位置下标，结束位置下标) 结束位置下标不包含
# find 返回下标位置，查不到返回-1
b = a.find('b',0,2)
print(b)  # 1
print(type(b))  # <class 'int'>

index() 用法和fin()一样 只是找不到以后会报错

count(字串，开始位置，结束位置) 作用是统计出现次数

a = 'abcdefg'
# find(字串，开始位置下标，结束位置下标) 结束位置下标不包含
# find 返回下标位置，查不到返回-1
b = a.find('b',0,2)
print(b)  # 1
print(type(b))  # <class 'int'>
# index 返回下标，查不到报错

# count 返回次数   字符串序列.count(⼦串, 开始位置下标, 结束位置下标)
c = a.count(a)
print(c)  # 1 

字符串修改

所谓修改，是通过函数的方式修改内容

 

a = 'abcdef'
# replace("原","现",次数)  replace 是有返回值的
b = a.replace("a","1")
print(b)
# replace 没有更改原字符串，
print(a)

# split 分割
# split 不包含被分割字串
c = a.split("a")  # ['','bcdef']
print(c)
print(a)

# join 拼接
list = ['chuan','zhi','bo','ke']
d = '-'.join(list)
print(d)

# 数字判断
num = '12345'
print(num.isdigit())  # True

 2)列表 相当于java 的数组

 

# 列表 相当于java 的数组
# 列表可以⼀次性存储多个数据，且可以为不同数据类型。
name_list = ["tom","rose","lily"]
print(name_list[1])  # tom

# 查找 index  返回数字下标 找不到报错
print(name_list.index("rose"))  # 1

# count 计数

# 列表长度
print(len(name_list))  # 3
print(type(len(name_list)))  # int

# in 判断是否存在 返回bool
print('tom' in name_list)  # True
# not in 不在 返回True

列表增加和删除

增加：apend(),extend(),insert()

append():追加

extend():拆散追加

insert()：指定位置添加

# append
name_list = ["tom","rose","lily"]
name_list.append("xiaoming")
print(name_list)   # ['tom', 'rose', 'lily', 'xiaoming']  列表是个可变类型
# append 追加序列 则出现 子序列
name_list.append(["zhangsan","lisi"])
print(name_list)

print(name_list[4][1])  # lisi 二维数组

#  extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
name_list = ["tom","rose","lily"]
name_list.extend("xiao ming")
print(name_list) # ['tom', 'rose', 'lily', 'x', 'i', 'a', 'o', ' ', 'm', 'i', 'n', 'g']
name_list = ["tom","rose","lily"]
name_list.extend(["zhangsan","lisi"])
print(name_list)

#列表序列.insert(位置下标, 数据)
name_list.insert(1,"xiaoming")
print(name_list)

删除：del() , pop(),remove(),clear()

del():可以删除列表，也可根据下标删除列表中的某个数据

por():根据i下标删除数据，并返回被删除数据

remove()根据元素删除对象

clear()清空列表

# 删除 del() 参数数组下标，不填删除整个数组
del(name_list[1])
print(name_list)
# 删除 pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。
list_name_pop = name_list.pop()
print(list_name_pop)  # lisi
print(name_list)   # ['tom', 'rose', 'lily', 'zhangsan']

# 删除 remove  根据元素删除对象
name_list.remove("zhangsan")
print(name_list)  # ['tom', 'rose', 'lily']
# clear 全清
name_list.clear()
print(name_list)  # []

 列表的修改 逆序 和复制

复制要注意，不等于=，等号涉及内存指向，只是让两个内存指向统一位置，类似java的栈和堆的区别

copy()是复制+赋值，开辟了新的内存空间

# 直接根据下标修改
name_list = ["tom","lily","rose"]
name_list[0] = "赵四儿"
print(name_list)  
# reverse() 逆置
name_list.reverse()
print(name_list)  # ['rose', 'lily', '赵四儿']

# 排序 列表序列.sort( key=None, reverse=False) reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
num_list = [1,5,2,3,1,2,6,7,4,8]
num_list.sort()
print(num_list)
num_list.sort(reverse=True)
print(num_list)

# 复制
print(name_list)  # ['rose', 'lily', '赵四儿']
name_list_copy = name_list
name_list.pop(0)
print(name_list)  # ['lily', '赵四儿']
print(name_list_copy)  # 引用指向， = 涉及引用 ['lily', '赵四儿']

name_list_copy = name_list_copy.copy()
name_list.pop(0)
print(name_list)  # ['赵四儿']
print(name_list_copy)  # ['lily', '赵四儿'] 独立的数组

列表循环

name_list = ["tom","lily","rose"]
i = 0
while i < len(name_list):
	print(name_list[i])
	i += 1


# for 循环
for i in name_list:
	print(i)

 3）元组，元组属于不可修改的数据类型

# 元组不可修改，列表可以修改  可以存放不同类型 元组数据不⽀持修改，只⽀持查找，具体如下
t1 = (10,20,'tom')
print(t1)

# 按下标查找
print(t1[1])
# index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index 相同
print(t1.index("tom"))

# 统计出现次数 count
print(t1.count("tom"))  # 1

# len() 返回元组长度
# 元组数据不能直接修改  例如：
# t1[1] = 'aa'  # 报错

# 但是元组内部有列表这类可以支持修改的数据类型，则可以对其进行修改
t2 = (10,20,['aa','bb','cc'])
t2[2][0] = '修改aa'
print(t2)  # (10, 20, ['修改aa', 'bb', 'cc'])

 4)字典

# 字典相当于java 里的 Map 有key - value
# 创建字典
dict1 = dict()

dict2 = {}

print(type(dict1))  # <class 'type'>

# 增
dict1['name'] = 'Tom'
print(dict1)  # {'name': 'Tom'}

# 删 del 函数
del(dict1['name'])
print(dict1)  # {}

# clear 清空
dict1 = {'name':'Tom','age':20,'sex':'man'}
dict1.clear()
print(dict1)  # {}

# 改 直接根据key 修改 内容，如果key 不存在 新增

# 查，根据key  dict[key]  如果key 不存在报错
dict2 = {'name':'Tom','age':20}
print(dict2['age'])  # 20

# get 方法  根据key查找，key不存在返回第二个参数，若第二个参数为空，返回None
print(dict2.get('name','张三'))  # Tom

# 返回 keys
print(dict2.keys())  # 返回值是列表形式的可迭代对象 dict_keys(['name', 'age'])

# 返回 values
print(dict2.values())  # dict_values(['Tom', 20])

# items  元组的可迭代对象
print(dict2.items())  # dict_items([('name', 'Tom'), ('age', 20)])


# 用 for 循环处理这些可迭代对象
for key in dict2.keys():
	print(key)  # name age

# values 一样处理

# 处理items
for item in dict2.items():
	print(item)  # ('name', 'Tom')
	print(type(item))  # <class 'tuple'> 元组

# 同时遍历 key 和 value  就是遍历元组的方式
for key,value in dict2.items():
	print(f'{key}---{value}')

5) 集合

# 集合创建
s1 = {1,'a',2,3}
# 空集合的创建只能用set()函数，因为{} 是空字典的创建方式
s2 = set()
# set() 函数 也可以带参数
s3 = set('1024')
print(s1)  # {3, 1, 'a', 2}
print(s2)  # set()
print(s3)  # {'4', '2', '1', '0'}

# 集合特点， 集合是无序的，集合可以去掉重复数据
# 增加：add()
s1.add(100)
print(s1)  # {1, 2, 3, 100, 'a'}

# 追加 update() 但只能是序列（包括字符串）
s1.update(['b'])
print(s1)  # {1, 2, 3, 100, 'b', 'a'}

# 删除remove 根据元素 ,删除集合里的数据，若该数据不存在，则报错
s1.remove(1)
print(s1)  # {2, 3, 100, 'b', 'a'}

# discard() 用法同 remove()
s1.discard('b')
print(s1)  # {'a', 2, 3, 100}

# pop() 随机删除指定数据，并返回被删除数据；注意是随机，不能指定数据
a = s1.pop()
print(a)
print(s1)


# 集合的查找用 in 和 not in  来判断，返回布尔值
bool = '1' in s3  # '1'字符串
print(bool)  # True

# 总结：
# 结合创建：分为有数据和无数据
s1 = {1,2,3}
s2 = set()  # 无数据

6）序列常用操作

# 拼接 + 和 *
s1 = 'a'
s2 = 'b'
print(s1+s2)  # ab

t1 = (1,2)
t2 = (3,4)
print(t1 + t2)  # (1,2,3,4)

# 求个数len()
print(len(s1))  # 1
print(len(t1))  # 2

# 清空
s1 = 'abcdef'
del s1
# print(s1)  # 报错，没定义，因为被删了

# del (t1[0])  # 元组不允许修改

list1 = [1,2,3,4]
del (list1[0])
print(list1)  # [2,3,4]

# 遍历 enumerate
print(type(enumerate(t1)))  # <class 'enumerate'>
for i in enumerate(t1):
	print(i)  # (1, 2)(0, 2)
for i, char in enumerate(t1):
	print(f"元组下标：{i},值：{char}")   # 元组下标：0,值：1

# 序列类型转换 set() list() tuple()，返回修改后的类型，原类型不变
list1 = [1,2,3]
t1 = tuple(list1)
print(t1)  # (1, 2, 3)
print(type(t1))  # <class 'tuple'>
print(type(list1))  # <class 'list'>  原类型不变

7)推导式，推导式是快速构建序列的方法，也可用wihle和for循环完成

列表推导式

#  推导式就是简化版的 序列创建，完全可以通过给 while 和 for 循环实现
list1 = [i for i in range(10)]
print(list1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]


# if 条件判断， 比如 0 - 9 的偶数列
list1 = [i for i in range(10) if i % 2 ==0]
print(list1)  # [0, 2, 4, 6, 8]

# 嵌套for 循环 构建二维数组
list2 = [(i,j) for i in range(3) for j in range(4)]
print(list2)  # [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]

 字典推导式

# 字典推导式分为，列表合并，字典选取，和创建字典
# 列表合并(两个列表的元素顺序不能错，要对应起来)
list_k = ['name','age','sex']
list_v = ['Tom','20','man']
dict1 = {list_k[i]:list_v[i] for i in range(len(list_k))}
print(dict1)  # {'name': 'Tom', 'age': '20', 'sex': 'man'}

# 字典数据选取
dict2 = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
print(dict2.items())  # dict_items([('MBP', 268), ('HP', 125), ('DELL', 201), ('Lenovo', 199), ('acer', 99)])
for key,value in dict2.items():
	print(f"key:{key},value:{value}")
count = {key: value for key,value in dict2.items() if value >= 200}
print(count)

# 字典数据创建  key:i  value:i*5
dict3 = {i: i * 2 for i in range(5)}
print(dict3)

集合推导式：

# 用法与 列表推导式一样
list1 = [1,1,2,3,4,5]
set1 = {i for i in list1}
print(set1)  # {1, 2, 3, 4, 5} 自带去重


# 总结
# 列表推导式
# [xx for xx in range()]

# 字典推导式
#{xx1 : xx2 for ... in ... }

# 集合推导式
# {xx for xx in ....}