-- 整型
a = 1
print(type(a))  # <class 'int'> 
-- 浮点型
b = 1.1
print(type(b))  # <class 'float'> 
-- 布尔型
c = True
print(type(c))  # <class 'bool'> 
-- 字符串
d = "12345"
print(type(d))  # <class 'str'> 
-- 列表
e = [10, 20, 30]
print(type(e))  # <class 'list'> 
-- 元组
f = (10, 20, 30)
print(type(f))  # <class 'tuple'> 
-- 集合
h = {10, 20, 30}
print(type(h))  # <class 'set'> 
-- 字典
g = {"name": "亚瑟", "age": 35}
print(type(g))  # <class 'dict'>

Python为什么会有这么多种数据类型呢？

适应不同的变量，合理使用内存。

家里别野太大了（狗头）健身房、衣帽间、花园可不得齐全嘛。

Python是弱类型语音，数据类型不太需要程序员在意！！！

三、输出

3.1、格式化输出

格式化输出是什么玩意不知道，那就换个说法占位符，占位这个位置以后再用的符号，哈哈类似图书馆的代书板。

符号	转换	符号	转换
%s(常用)	字符串	%x	十六进制整数（小写ox）
%d(常用)	有符号的十进制整数	%X	十六进制整数（大写OX）
%f(常用)	浮点数	%e	科学计数法（小写e）
%c	字符	%E	科学计数法（大写E)
%u	无符号的十进制整数	%g	%f和%e的简写
%o	八进制整数	%G	%f和%E的简写

%03d，表示整数的最少显示位数，不足就用0补齐，例如1显示为001，而1111就是1111原样显示。%.2f，表示浮点型的小数保留位数，3.1415926显示为3.14。

name = "瑶"
age = 16
weight = 45
student_id = 1

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

# 我的学号是0001
print('我的学号是%04d' % student_id)

# 我的体重是45.00公斤
print('我的体重是%.2f公斤' % weight)

# 我的名字是瑶，今年16岁了
print('我的名字是%s，今年%d岁了' % (name, age))

# 我的名字是瑶，明年17岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))

3.2、内置函数format

用于字符串格式化，功能超级厉害，活脱脱就是一个超级占位符，哈哈。

格式是：str.format()，不限参数格式也不要求位置，一一对应就好啦。

# 我的名字是瑶，明年17岁了
print('我的名字是{0}, 明年{1}岁了'.format(name, age+1))

# 我的名字是云中君，今年20岁了
print('我的名字是{0}, 今年{1}岁了'.format("云中君", 20))

3.3、f-格式化字符串

额，虽然难以解释，但是确实又是一种格式化字符串的方法。会更简洁，可读性更好，而且速度更快哦。格式为：f'{表达式}'

# 我的名字是瑶，明年17岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')

3.4、真相！

事实上，字符串输出的本质就是拼接字符串，都用%s其实也是可以的，反正……整型也好浮点型也罢最后都要转成字符串。

3.5、转义字符与结束符

\n：换行
\t：制表符
事实上python的print()结束时会默认加一个print('内容', end="\n")，不过我们可以自己改啦

四、输入

4.1、语法

input("提示信息")

4.2、特点

当程序执行到input时，须用户输入完成才能继续向下执行
一般输入内容存储到变量中，便于使用
input接收到的输入数据都将作为字符串处理

五、转换数据类型

葫芦娃：“用户输入的内容可不是面团捏的！”。

拿来把你！我就要浮点型！哈哈

函数	说明	函数	说明
int(x)	将x转换为整形	list(s)	将序列s转换为列表
float(x)	将x转换为浮点形	chr(x)	将一个整数转换为Unicode字符
str(x)	将x转换为字符串	ord(x)	将一个字符转换为ASCII字符
repr(x)	将x转换为表达式字符串	hex(x)	将一个整数转换为十六进制字符串
eval(str)	将字符串中的数据转换成Python表达式原本类型	oct(x)	将一个整数转换为八进制字符串
tuple(s)	将序列s转换为元组	bin(x)	将一个整数转换为二进制字符串

六、运算符

七、条件语句

7.1、简介

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

换言之，满足条件就执行。

7.2、if语句

if 判断条件:
    执行语句…
elif 判断条件:
    执行语句…
else：
    执行语句…

7.3、if语句实例

# __anthor: XU CHEN
# date: 2021/9/18

import random
import sys

print("欢迎来到石头剪刀布小游戏")
userName = input("请输入你的游戏名称:")


def Game(inNum, comNum):
    if inNum == comNum:
        print(f'机器出了{comNum}，平局！')
    elif (inNum==0 and comNum==2) or (inNum-comNum==1):
        print(f'机器出了{comNum},你赢了！')
    else:
        print(f'机器出了{comNum}，你输了…')
    res = input('再来请输入X，退出请按任意键')
    if res == 'X' or res == 'x':
        return
    else:
        sys.exit(0)


while True:
    stats = input(f'欢迎{userName}来到本游戏，开始游戏输入Y，推出游戏输入N：')
    if stats == 'Y' or stats == 'y':
        print('游戏开始！')
        print('石头输入0、剪刀输入1、布输入2')
        inNum = int(input("请您出拳"))
        if inNum == 0 or inNum == 1 or inNum == 2:
            comNum = random.randint(0, 2)
            Game(inNum, comNum)
        else:
            print('输入有误')
    elif stats == 'N' or stats == 'n':
        print('游戏结束！')
        sys.exit(0)
    else:
        print("请按照要求重新输入！")

7.4、三元运算符

exp1 if contion else exp2

max = a if a>b else b

八、循环

8.1、作用

提高代码的复用率，像反复使用的环保袋一样，便宜又环保，嘿嘿

8.2、while

while 条件表达式：
代码块

8.3、for

for 迭代变量 in 字符串|列表|元组|字典|集合：
代码块

8.4、break和continue

break和continue是循环中满足一定条件退出循环的两种不同方式。

break结束循环，而continue是跳过当前循环。

8.5、循环…else

正常结束循环才执行else哦，break结束是不属于的。

while 条件:
    条件成立重复执行的代码
else:
    循环正常结束之后要执行的代码

九、字符串

9.1、简介

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。

三引号字符串是支持换行的哦。如果引号里还需要使用引号的话，就需要使用转义符啦

9.2、下标

又叫”索引“，就是字符串中每一个字符的座位号啦。

name = "abcdef"

print(name[1])
print(name[0])
print(name[2])

输出就是：b a c（python是从0开始的哦）

9.3、切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作

序列[开始位置下标:结束位置下标:步长]

就像切土豆片一样啦，从哪里切到哪里，每一片多厚。土豆片薄薄的才好吃！步长为-1的意思就是倒序哦。而结束下标是-1则意味着最后一个字符。都为空的话就是从头到尾步长1的意思啦。

9.4、常用操作方法

9.4.1、查找

通常是查找目标子串出现的位置或者返回的次数啦。

字符串序列.find(子串, 开始位置下标, 结束位置下标)

检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。开始和结束下标都可以省略，表示在整个字符串序列中查找。

字符串序列.index(子串, 开始位置下标, 结束位置下标)

和find不同点是：没有找到子串则报异常

rfind()：和find()功能相同，但查找方向为右侧开始。
rindex()：和index()功能相同，但查找方向为右侧开始。
count()：返回某个子串在字符串中出现的次数。

字符串序列.count(子串, 开始位置下标, 结束位置下标)

9.4.2、修改

字符串序列.replace(旧子串, 新子串, 替换次数)

数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

字符串序列.split(分割字符, num)

num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。如果分割字符是原有字符串中的子串，分割后则丢失该子串。

连接字符或子串.join(多字符串组成的序列)

capitalize()：将字符串第一个字符转换成大写。

title()：将字符串每个单词首字母转换成大写。

lower()：将字符串中大写转小写。

lstrip()：删除字符串左侧空白字符。

rstrip()：删除字符串右侧空白字符。

strip()：删除字符串两侧空白字符。

ljust()：返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度的新字符串。

rjust()：返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度的新字符串，语法和ljust()相同。

center()：返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度的新字符串，语法和ljust()相同。

9.4.3、判断

所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。

字符串序列.startswith(子串, 开始位置下标, 结束位置下标)

startswith()：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

字符串序列.endswith(子串, 开始位置下标, 结束位置下标)

endswith()：：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。

isdigit()：如果字符串只包含数字则返回 True 否则返回 False

isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

isspace()：如果字符串中只包含空白，则返回 True，否则返回 False。

十、列表

10.1、简介

列表的格式是[数据1, 数据2, 数据3, ...]，列表可以一次性有序存储多个不同类型的数据。

10.2、对列表增删改查吧！

10.2.1、查找

方法一：根据下标索引数据，其实就和查字符串是一样一样的啦。

name_list[0]

方法二：使用函数查位置个数或者长度

index()查位置，找不到可是会报错的哦

列表序列.index(数据, 开始位置下标, 结束位置下标)

count()数个数

name_list.count('Lily')

len()数长度

len(name_list)

判断是否存在可以用in、not in

10.2.2、新增

方法一：append()追加一个数据到列表的结尾哦。

不过使用append()新增数据，会使列表变为可变数据类型哦。

如果追加的数据是一个序列，append()会把序列当作一个数据放在原列表中。

列表序列.append(数据)

方法二、extend()追加一个数据到列表的结尾

和append()不同，如果追加的数据是一个序列，extend()会将数据逐一添加到原列表中。

列表序列.extend(数据)

方法三、insert()指定位置新增数据

和append()、extend()又不同啦，insert可以指定新增的位置哦，所以方法传参需要指定插入位置。

如果新增的数据是一个序列，insert()和append()一样会打包插入。

列表序列.insert(位置下标, 数据)

10.2.3、删除

方法一、del，del不仅可以删除列表元素，连列表都可以直接删除哦

对了，有没有发现del后面没有括号，哈哈，因为它是关键字而不是内置方法

del 目标
del myList[2]

方法二、pop()，删除指定下标的数据。

pop()是有默认值和返回值的哦，默认是最后一个，返回删除的数据。

列表序列.pop(下标)

方法三、remove()，移除列表中某个数据的第一个匹配项

就好像先根据数据用index()查出下标，然后根据下标del删除数据啦。

所以如果没有的话也是会报错的哦！

列表序列.remove(数据)

方法四、clear()清空列表

name_list.clear()

10.2.4、修改

a) 直接根据下标重新赋值，这是对单个位置的数据的修改最便捷的办法啦。

b) 逆置/倒序：reverse()

c) 排序：sort()，可以通过参数更改正逆哦，reverse = False升序(默认)

列表序列.sort( key=None, reverse=False)

10.2.5、复制

copy()，copy后的列表和原列表，即使数据相同，但是在内存中指向的不同的地址哦。

十一、元组

元组不可修改！元组不可修改！元组不可修改！

11.1、定义

列表定义用中括号，元组定义用小括号()

如果元组数据只有一个数据A的话，也要加逗号哦！

不过不加的话，元组数据类型就是数据A的数据类型啦！

t2 = (10,)
print(type(t2))  # tuple

t3 = (20)
print(type(t3))  # int

11.2、查询

我们第一句话说的啥？没错！元组不可修改，自然也就不能新增，不能修改，不能删除。

元组只能查询哦。

方法一：根据下标索引数据，和字符串、列表方法一样

方法二：index()，根据数据查下标，没有的话会报错的哦，语法和字符串列表也是一样啦

方法三：count()，统计数据出现次数

方法四：len()，统计元组数据个数

11.3、注意事项

元组不能修改！修改就报错！
虽然元组不可修改，但如果元组里面有列表的话，元组中的列表中的数据是可以修改的哟

tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2])  # 访问到列表

# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)

十二、字典

字典的数据结构是键值对。无序！可变！

12.1、创建字典的语法

列表是[]，元组是()，字典是{}

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()

对了，键值对是啥？冒号前为键后为值

12.2、增删改查

12.2.1、新增&修改

语法：字典序列[key] = value

如果key已经存在的话就会重新赋值啦，不存在才会新增此键值对。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

dict1['name'] = 'Rose'
# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)

12.2.2、删除

方法一、del/del()：del可以删除指定键值对（键和值一起删！），还可以直接删除字典哦。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

del dict1['gender']
# 结果：{'name': 'Tom', 'age': 20}
print(dict1)

方法二、clear()：清空字典。字典序列.clear()

12.2.3、查询

方法一、按键查值，没有会报错哦！

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name'])  # Tom
print(dict1['id'])  # 报错

方法二、get()

字典序列.get(key, 默认值)

如果key不存在会返回默认值（默认是：None）

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name'))  # Tom
print(dict1.get('id', 110))  # 110
print(dict1.get('id'))  # None

方法三、keys()，查询字典中所有的键

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())  # dict_keys(['name', 'age', 'gender'])

方法四、values()，查询字典中所有的值

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())  # dict_values(['Tom', 20, '男'])

方法五、items()，查询每一项键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())  # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

12.3、循环遍历

字典遍历key、value、items都可以用查询方法，使用for in()遍历

但是遍历键值对：

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{key} = {value}')

十三、集合

集合具有确定性、无序性和去重性。

13.1、创建

创建集合可以使用set{}，也可以和字典一样都用{}，如果大括弧里是键值对那就是字典，如果是单个元素那就是集合。如果大括弧为空那这是一个空字典而不是空集合哦！创建空集合只能使用set()。

集合可以去重！集合无序以为着不能下标索引！

13.2、增删查

为什么没有改呢？因为改没有意义，不需要了可以直接删除，需要新的可以直接新增啦！

13.2.1、查询

in和not in，判断数据是否在集合之中

13.2.2、新增

方法一、add()用于增加单个元素，如果已存在就不会进行操作啦。

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)  # {100, 10, 20}

方法二、update()用于增加序列（逐个增加哦，不是直接打包）

s1 = {10, 20}
# s1.update(100)  # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)   # {'a', 100, 200, 10, 'b', 'c', 20}

13.2.3、删除

方法一、remove()删除指定数据

集合.remove()

方法二、discard()删除指定数据

集合.remove()

方法三、pop()随机某个数据，并返回

集合.pop()

十四、公共操作

14.1、运算符

14.1.1、合并（+），可用于字符串、列表、元组

# 1. 字符串 
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3)  # aabb


# 2. 列表 
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3)  # [1, 2, 10, 20]

# 3. 元组 
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3)  # (10, 20, 100, 200)

14.1.2、复制（*），可用于字符串、列表、元组

# 1. 字符串
print('-' * 10)  # ----------

# 2. 列表
list1 = ['hello']
print(list1 * 4)  # ['hello', 'hello', 'hello', 'hello']

# 3. 元组
t1 = ('world',)
print(t1 * 4)  # ('world', 'world', 'world', 'world')

14.1.3、元素是否存在（in、not in），可用于字符串、列表、元组、字典

# 1. 字符串
print('a' in 'abcd')  # True
print('a' not in 'abcd')  # False

# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1)  # True
print('a' not in list1)  # False

# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1)  # False
print('aa' not in t1)  # True

14.2、公共方法

14.2.1、range(start, end, step)

生成从start到end的数字，步长为 step，供for循环使用。

range是左包围！！！

# 1 3 5 7 9
for i in range(1, 10, 2):
    print(i)

14.2.2、enumerate()

enumerate(可遍历对象, start=0)

函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。start参数用于设置被遍历数据的下标的起始值，默认为0。

list1 = ['a', 'b', 'c', 'd', 'e']

for i in enumerate(list1):
    print(i)

for index, char in enumerate(list1, start=1):
    print(f'下标是{index}, 对应的字符是{char}')

14.3、容器类型转换

啥？什么是容器？容器就是可以装不同数据类型元素的…数据类型啦！

啥？容器类型有哪些？字符串、列表、元组、字典、集合都是哦

14.3.1、list()

作用：将某个序列转换成列表

字符串转换为列表时，会把字符串中的每一个字符当做列表的元素

集合、元组和字典都可以转换为 list列表类型，但是字典只保留了字典中的键

# n = {'name':'zhangsan','age':20}
# res = list(n)
# print(n,type(n),res,type(res))

14.3.2、tuple()

作用：将某个序列转换成元组

# n = {'name':'zhangsan','age':20}
# res = tuple(n)
# print(n,type(n),res,type(res))

14.3.3、set()

作用：将某个序列转换成集合。

# n = {'a':1,'b':2}
# res = set(n)
# print(n,type(n),res,type(res))

标签：20,name,Python,基础,元组,语法,字符串,print,列表
来源： https://blog.csdn.net/weixin_42956490/article/details/120365763

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Python基础语法（上）

一、变量

1.1、变量的作用

1.2、Python的变量定义

二、数据类型