python基础(阅读需要C&C++基础){注释}{input}{切片}{基本数据类型}

一 python注释

1、python中注释很简单，哪里要写注释就在最前面加上一个#号即可；
2、没有多行注释，每行都需要写；
3、用’‘’ 多行代码 ‘’'或者"“” 多行代码 “”"创建字符串而不赋值给变量的方式，也可以实现多行注释，可用于函数注释；

二 input()

1 返回的值是string类型，运算需要强转

注意：如果直接相加，不会报错而执行string类型的append；

a=input();b=input()
print(a+b,type(a),type(b))

12
1.2
121.2<class 'str'> <class 'str'>

1.1 输入时强转

a=int(input());b=int(input())
print(a+b,type(a),type(b))

12
23
35<class 'str'> <class 'str'>

1.2 运算时强转

a=input();b=input()
print(int(a)+int(b),type(a),type(b))

12
23
35<class 'str'> <class 'str'>

2 提示字符串

2.1 input里只能放一个参数

多个字符串之间不能用‘ , ’ 而应该用‘ + ’ ，可以是字符串常量，也可以是字符串变量，也可以是强转字符串；

a=input('hello','dh')
#会报下面的错误：
TypeError: input expected at most 1 argument, got 2//说只能有一个参数，这里有两个

a=input('hello'+' world')#字符串相加合并成一个
b='nihao'
c=input(b+' world')#也可以是字符串变量；
d=11223
e=input(b+str(d))#也可以是强转之后的str
#下面为正确输出：每行最后的数字为手动输入
hello world1
nihao world2
nihao112233

3 一次性输入多个变量

3.1 用split()获得字符串列表

3.1.1 split(括号内的字符串用来设定分隔符)；如split(‘,’)是设置逗号为分隔符；
3.1.2 对字符串调用split()：使用分隔符将字符串分割成列表；
3.1.3 input()返回字符串，input().split()即可获得字符串列表实现一次性获得多个参数；

a=input().split()
print(a)
a=input().split('+')
print(a)
a=input().split(',')
print(a)
#以下为程序输出：
1 2 3		#以空格间隔输入
['1', '2', '3']
1+2+3+4		#以+间隔输入
['1', '2', '3', '4']
1,2,3,4,5	#以逗号间隔输入
['1', '2', '3', '4', '5']

3.2 用map() 一次性强转列表

map() 可以接收函数和列表，使函数作用于列表中每一个元素并返回作用后元素的集合，用强转函数和split()返回的列表就可以实现一次性获取多个指定类型的输入，注意最后返回的是集合而不是列表；

a=input().split()
print(a)
b,c,d=map(int,input().split())
print(b,c,d)
#以下为程序输出：
1 2 3
['1', '2', '3']
1 2 3
1 2 3

三 切片

1 python中的索引

1.1 正向索引

从左向右索引，下标从0开始0，1，2，，，

1.2 负向索引

从右向左索引，下标从-1开始-1，-2，-3，，，

2 怎么切片/切片的表达式

切片操作基本表达式：object[ start : end : step ]，参数分别为起始下标，终止下标，步进值；

2.1 操作会切出包含起始元素，不包含终止元素的序列，

即 [ start，end ) ；

2.2 索引方向和步进方向的问题

2.2.1 两个索引的正负一样

(1) 索引可以正向或负向索引；
(2) 步进值的正负决定是顺序取还是逆序取；
(3) 两个方向要一致；才可以取到数据，否则返回的序列为空；(第一个值也不取)
比如正向索引+负步进值[0：2：-1]，将从下标0开始往左取值，显然取不到值；这里需要结合2.3.1(2)来完整理解；

2.2.2 两个索引的正负不一样

索引的正负可以混用，原则是只要起始索引在终止索引的左边，则为正向索引；只要起始索引在终止索引的右边，则为负向索引；
虽然语法上支持这样，但是可读性很差，不建议；

2.3 切片中的省略

2.3.1 省略冒号及参数

(1) 完整的切片表达式有2个“ ：”，
(2) 如果只有1个，默认step=1；
注意：如果省略step，不管索引方向，都默认为1；因此在负向索引的情况下会取空；
同时注意：必须两个索引都不省略才可以判断是正向还是负向索引，如果只省略了一个，则要具体地根据step的正负以及没有省略的索引的值来判断；
(3) 如果没有“ ：”，则写谁取谁；

2.3.2 只省略参数

(1) 省略起始下标
表示从第一个开始取，根据step的正负选择从正向起点还是正向终点开始取；
(2) 省略终止下标
表示取到最后，包括最后一个元素，根据step正负决定最后一个元素是正向起点还是正向终点；

2.4 切片用法举例

以a=[1,2,3]为例
2.4.1 切取一个元素
a[0]，即写谁取谁
2.4.2 取整个序列
a[:]
a[::]
a[::-1]
2.4.3 取偶数、取奇数(取的是位置与具体值无关)
2.4.4 拷贝对象(浅拷贝)
2.4.5 直接修改一个或多个值
将切片用于左值，可以完成修改元素、插入元素、删除元素的目的；

a=[0,1,2,3,4,5]
print(a)
#修改元素
a[0:3]=[7,8,9]
print(a)
#删除元素
a[:3]=[7]
print(a)
#指定位置插入元素
a[0:0]=[6]
print(a)
#指定位置插入元素
a[2:2]=[8,9]
print(a)
#指定位置的元素变成一个列表
a[2]=[1]
print(a)

[0, 1, 2, 3, 4, 5]
[7, 8, 9, 3, 4, 5]
[7, 3, 4, 5]
[6, 7, 3, 4, 5]
[6, 7, 8, 9, 3, 4, 5]
[6, 7, [1], 9, 3, 4, 5]

注意最后一组，两个索引和一个索引所产生的结果不同；两个索引是切片操作，对一个切片列表操作，而一个索引是对指定位置一个具体的元素进行操作；

四 基本数据类型

number（数字）
string（字符串）
tuple（元组）
list（列表）
set（集合）
dictionary（字典）
前三种为不可变数据类型，改变只能间接操作；

1 number（数字）

1.1 有int, float, bool, complex 四种基本类型，用于存储数值

1.2 相互可以类型转换：int(),float()…

1.3 数学运算 ：

(1) +、-、* 、%与C语言相同
(2) / 表示做浮点数除法 ，(直接实现完整除法)
(3) // 表示做保留整数除法（与C语言的/相同）
(4) ** 表示做幂次方运算 （注意运算次序）

2 string（字符串）

2.1 字符串支持比较和成员操作符，返回Ture或False

比较有>，<，==，!=，>=，<=；比较方式与C相同
成员操作符有in和not in；

2.2 字符串支持索引和切片

2.3 字符串的拼接

2.3.1 连接符 +
2.3.2 join()

s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))
#以下为输出：
r-u-n-o-o-b
runoob

2.3.3 直接连着写

a="hello"''' ''''world'
print(a)
#以下为输出：
hello world

2.4 重复操作符 *

a='hello'*2+3*'ni'
print(a)
#以下为输出：
hellohelloninini

2.5 字符串的内建函数

用dir()方法返回内建函数列表；

print(dir(str))
#以下为输出：
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

3 tuple（元组）

3.1 元组 ：(元素列表。。。)

(1) 元素可以为任意类型；
(2) 支持索引，可下标访问；
(3) 空元组：( )
(4) 单元素元组： ( 单元素 ，) ；单个元素后加上，表示这是一个元组，而不是一个元素加了括号；
(5) 支持成员操作符in 和 not in

3.2 元组不可变

指的是元组本身不可变，不能通过下标访问元素改值，也没有append()等方法，即不能直接修改；
注意：元组中的元素可以是列表，元组中的列表仍然是可变的；

3.3 元组的间接修改

3.3.1 重复操作符 *
3.3.2 连接操作符 +
3.3.3 切片

3.4 元组的内建函数

print(dir(tuple))
#以下为输出：
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

4 list（列表）

4.1 列表： [ 元素列表。。。]

(1)元素可以为任意类型
(2) 空列表 [ ]
(3) 支持索引，下标访问
(4) 单元素列表不用加逗号，区别于元组
(5) 列表可变，可以直接通过下标访问改值，也可以有append()等操作
(6) 支持in 和not in成员操作符

4.2 列表的间接修改

4.2.1 切片
4.2.2 重复操作符 *
4.2.3 连接操作符 +

4.3 列表的增删查改

4.3.1 增
(1) append(一个元素)在结尾追加一个元素
(2) extend(元素列表)在结尾追加多个元素
(3) insert(索引值，元素)在指定位置插入一个元素
4.3.2 删
(1) remove(元素) 删除指定元素,如果删除不存在的元素，报KeyError；
(2) pop(索引) 弹出索引位置的元素，如果不写索引，默认弹出最后一个元素，该方法返回弹出的元素，注意不能用于空列表，否则报错
(3) del 列表[切片] 删除切片范围的元素
(4) del 列表：直接删除列表
4.3.3 改
通过切片改
4.3.4 查
(1) cout(元素) count()方法统计元素数量
(2) index(元素) index()方法返回元素最小索引
(3) index(元素，索引前，索引后) 这种返回[ 索引前，索引后 ）范围中的索引值，注意，与切片相同，索引前可以取到，索引后不行；
4.3.5 排序
(1) sort()方法 对一个列表进行排序，按ascll码排序
sort(key=str.lower) ###对字符串排序不区分大小写，相当于将所有元素转换为小写，再排序
sort(key=str.upper) ###相当于将所有元素转换为大写，再排序
(2) sorted(列表) 返回排序后的列表
注意类型一致才能排序
4.3.6 随机打乱顺序
需要用到random类中的静态方法shuffle()

a=[1, 2, 3, 4, 7, 9]
import random
random.shuffle(a)
print(a)
random.shuffle(a)
print(a)
random.shuffle(a)
print(a)
#以下为输出，每次都是随机排序
[4, 1, 3, 7, 2, 9]
[9, 1, 7, 4, 3, 2]
[3, 2, 9, 4, 7, 1]

4.4 列表的内建函数

print(dir(list))
#以下为输出：
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

5 set（集合）

5.1 创建集合

方式一：直接写出集合，用花括号，元素间以逗号分隔；如：

a={1,2,3,4,5}

注意：元素类型可以混合，但不能包含可变元素：列表，集合，字典；
方式二：用set()函数，里面只能写一个参数，不能是数字类型，应该是一个元组或列表或集合或字典，它们里面的值将被“打散”成集合的元素。

a={1,2,3}#直接写出集合
print(a,type(a))
a=set(('1a',2))#用元组
print(a,type(a))
a=set(['1a',2])#用列表
print(a,type(a))
a=set('abc')#用字符串
print(a,type(a))
a=set({1,2})#用集合
print(a,type(a))
#以下为输出：
{1, 2, 3} <class 'set'>
{2, '1a'} <class 'set'>
{2, '1a'} <class 'set'>
{'b', 'a', 'c'} <class 'set'>
{1, 2} <class 'set'>

创建空集合
a=set() 用set()方法创建，不写参数，或者写空元组或空列表；

5.2 集合的特点

数学上的集合：无序性，互异性，确定性；python中集合也具有这些性质；
5.2.1 无序性：集合中的元素没有确定的顺序，即不支持索引和切片；
5.2.2 互异性：一个元素，即使添加多次，仍只有一个；
5.2.3 确定性： 支持成员操作符in 和 not in ；且不包含可变元素；

5.3 集合的运算

5.3.1 判断一个集合是否是另一个的子集
(1)子集操作符“ < ”，判断左是否为右子集，返回bool数；
(2)方法issubset()；issuperset()

a={1,2,3,4}
b={1,2,3}
c={3,4,5}
print(b<a,c<a)
print(b.issubset(a),c.issubset(a),a.issuperset(b),a.issuperset(c))
#以下为输出
True False
True False True False

5.3.2 交集
(1) &运算符
(2) intersection()方法

b={1,2,3}
c={3,4,5}
print(b&c)
print(b.intersection(c))
#以下为输出
{3}
{3}

5.3.3 并集
(1) | 运算符
(2) union()方法

b={1,2,3}
c={3,4,5}
print(b|c)
print(b.union(c))
#以下为输出
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}

5.3.4 差集
是左集合的元素中不属于右集合的元素组成的集合；
(1) - 运算符
(2) difference()方法

b={1,2,3}
c={3,4,5}
print(b-c)
print(b.difference(c))
#以下为输出
{1, 2}
{1, 2}

5.3.5 对称集
两集合除了交集之外的所有元素的集合；
(1) ^ 运算符
(2) symmetric_difference()方法

b={1,2,3}
c={3,4,5}
print(b^c)
print(b.symmetric_difference(c))
#以下为输出
{1, 2, 4, 5}
{1, 2, 4, 5}

5.4 集合的增，删，查

5.4.1 增
(1) add()方法，增加一个元素；
(2) update() 方法，通过元组，列表，字符串，集合来添加多个元素；

a={1,2}
a.add('abc')
print(a)
a.update('abc')
print(a)
a.update((3,4))
print(a)
a.update([6,7])
print(a)
a.update({0,'hello'})
print(a)
#以下为输出
{1, 2, 'abc'}
{1, 'a', 2, 'c', 'abc', 'b'}
{1, 'a', 2, 'c', 3, 4, 'abc', 'b'}
{1, 'a', 2, 'c', 3, 4, 6, 7, 'abc', 'b'}
{0, 1, 'a', 2, 'c', 3, 4, 6, 7, 'abc', 'hello', 'b'}

5.4.2 删
(1) 删除一个元素
discard(元素)方法：若元素不存在无操作；
remove(元素)方法：若元素不存在报错；
pop()方法，不写参数，随机弹出一个元素；
(2) clear()方法：清空集合；

5.5 集合的方法与支持的内置函数

print(dir(set))
#以下为输出：
['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

函数	描述
all()	如果集合中的所有元素都是 True（或者集合为空），则返回 True。
any()	如果集合中的所有元素都是 True，则返回 True；如果集合为空，则返回 False。
enumerate()	返回一个枚举对象，其中包含了集合中所有元素的索引和值（配对）。
len()	返回集合的长度（元素个数）
max()	返回集合中的最大项
min()	返回集合中的最小项
sorted()	从集合中的元素返回新的排序列表（不排序集合本身）
sum()	返回集合的所有元素之和

6 dictionary（字典）

迭代/哈希

import

print

参考

【Python】input()函数用法小结
(转)彻底搞懂Python切片操作
Python字符串总结大全
Python：列表 【全用法】
Python 集合