Python基础

一丶变量

1.Python中变量赋值不需要声明

2.每个变量在使用前必须赋值

3.变量名=值

age = 18
salary = 9999.99
name =‘xiaSir‘
li = [1,2.1,‘a‘,[1,2,3]]
ids = (0,1,2,3,4)
dic = {‘name‘:‘xiaSir‘,‘age‘:10}
# 多变量赋值
a = b = 1

二丶数字

• int(有符号整型)
• flaot(浮点型）
• complex(复数)

　　1.进制转换

# 二进制转十进制
int(‘1101101‘,2)
# 八进制转十进制
int(‘0o226‘,8)
# 十六进制转十进制
int(‘0x96‘,16)
# 十进制转二进制
bin(123)
# 八进制转二进制
bin(0o56)
# 十六进制转二进制
bin(0xf6)
# 十进制转八进制
oct(213)
# 二进制转八进制
oct(0b100101010)
# 十六进制转八进制
oct(0x6dc)
# 十进制转十六进制
hex(12)
# 二进制转十六进制
hex(0b1010)
# 八进制转十六进制
hex(0o127)

三丶字符串

字符串或串(String)是由数字、字母(汉字)、下划线组成的一串字符

name = ‘xiaSir‘

conutry = ‘中国‘

　　1.字符串索引：

　　从左到右：默认从0开始，最大为字符串长度-1

　　从右到左：默认从-1开始，最大范围是字符串开头

　　2.字符串常用操作

# 字符串常用功能

# 1.去除首尾空格
a = ‘   hello ‘
print(a.split())
# 2.删除左边指定字符
a = ‘ahello‘
print(a.lstrip(‘a‘))
# 3.删除右边指定字符
a = ‘hello ‘
print(a.rsplit())

# 4.字符串拼接
a = ‘hello ‘
b = ‘word‘
print(a + b)
# -------------------------
li = [‘hello‘, ‘word‘]
s = ‘ ‘.join(li)
print(s)

# 字符串查找
# str.index 检测字符串中是否包含子字符，返回索引，可指定范围，找不到报错
a = ‘hello word‘
a.index(‘h‘)
a.index(‘a‘)
# ste.find 检测字符串中是否包含子字符，返回所有，可指定范围，找不到返回 -1
a.find(‘o‘)
a.find(‘a‘)
# 是否包含字符串
b = ‘abc‘ in a
print(b)
b = ‘abc‘ not in a
print(b)

# 字符串长度
a = ‘hello word‘
print(len(a))

# 字符串大小写转换
# 1.全部转小写
name = ‘xiaSir abc‘
print(name.lower())
# 2.全部转大写
print(name.upper())
# 3.大小写互换
print(name.swapcase())
# 4.首字母大写
print(name.capitalize())
# 单词首字母大写
print(name.title())

# 将字符串在指定长度居中，可指定2边字符
a = ‘hello world‘
print(a.center(40,‘*‘))
# 靠左
print(a.ljust(40,‘*‘))
# 靠右
print(a.rjust(40,‘*‘))

# 字符串统计
a = ‘hello word‘
print(a.count(‘l‘))

#字符串判断
S.startswith(prefix[,start[,end]])   #是否以prefix开头
S.endswith(suffix[,start[,end]])     #以suffix结尾
S.isalnum()                          #是否全是字母和数字，并至少有一个字符
S.isalpha()                          #是否全是字母，并至少有一个字符
S.isdigit()                          #是否全是数字，并至少有一个字符
S.isspace()                          #是否全是空白字符，并至少有一个字符
S.islower()                          #S中的字母是否全是小写
S.isupper()                          #S中的字母是否便是大写
S.istitle()                          #S是否是首字母大写的

# 字符串切片
str = ‘0123456789‘
print(str[0:3])     #截取第一位到第三位的字符
print(str[:])       #截取字符串的全部字符
print(str[6:])      #截取第七个字符到结尾
print(str[:-3])     #截取从头开始到倒数第三个字符之前
print(str[2])       #截取第三个字符
print(str[-1])      #截取倒数第一个字符
print(str[::-1])    #创造一个与原字符串顺序相反的字符串
print(str[-3:-1])   #截取倒数第三位与倒数第一位之前的字符
print(str[-3:])     #截取倒数第三位到结尾
print(str[:-5:-3])  #逆序截取，截取倒数第五位数与倒数第三位数之间

# 字符串替换
a = ‘hello word‘
print(a.replace(‘word‘, ‘python‘))

 三丶列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

 li = [1,2.1,‘a‘,[1,2,3]] 

　　1.列表操作

　　向列表中添加元素

# append(元素1)     在列表的最后添加一个元素
# insert(索引, 元素1)     在指定索引处添加一个元素
# extend([元素1, 元素2, 元素...])   在列表最后添加多个元素
li = [1,2,3]
li.append(4)
li.insert(2,‘a‘)
li.extend([‘a‘,‘b‘,1.1])
print(li)

　　删除列表中的元素

# remove()    移除指定元素
# pop()       弹出最后一个元素
# del li[index]   删除指定索引处的元素，del是一个操作语句，并不是列表的方法

li = [1,2,3,4,5]
li.remove(4)
li.pop()
del li[0]

　　列表切片，与字符串切片操作一样

li = [1,2,3,4,5,6,7]
li[1:3]
li[:5]
li[:-2]
li[::2]
li[::-1]

　　列表元素查看

count(A)：输出元素A在列表m里面出现的次数
index(A)：输出元素A在列表m里面的索引位置号,从左到右查
index(A,a,b)：对于列表m里面包含多个元素A时，输出在列表m索引号a-b之间的特定索引号

　　其他操作

reverse()：将列表m进行前后的翻转，前变后，后变前
sort()：将列表m里面地数据进行从小到大的排列
sort(reverse=True)：将列表m里面地数据进行从大到小的排列

四丶元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。

 五丶字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典是无序的

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ：{key1:value1,key2:value2}

d = {
    "k1": 18,
    "k2": True,
    "k3": [‘Su‘, {
        ‘kk1‘: ‘vv1‘,
        ‘kk2‘: ‘vv2‘,
        ‘kk3‘: (11, 22),
    }
           ],
    "k4": (11, 22, 33, 44)
}

　　1.字典操作

# 创建一个字典
obj = dict([[‘name‘,‘XiaSir‘],[‘age‘,10]])# 取值
name = obj[‘name‘]
for k,v in obj.items():
    print(k,v)

　　2.字典方法

# 1.删
d = {‘abc‘: ‘2341‘, 9102: ‘Bibi‘, (11,22): ‘3258‘}
del d[9102]     # 删除元素 9102:Bibi
print(d)        # 打印结果：{‘Alice‘: ‘2341‘, (11, 22): ‘3258‘}
d.clear()       # 清空字典
print(d)        # 打印结果：{}
del d           # 删除字典
d.pop(‘abc‘)    # 删除指定键-值，可指定返回值，如果不指定，当字典中没有这个key时就会报错
d.popitem()     # 随机删除一组键-值

# 2.查
# item()    获取k,v 返回一个元组
d.items()
# keys()    获取所有的key
d.keys()
# values()  获取所有的vlue
d.values()
# get()方法根据key获取值 get(self, k, d=None) 
d = {‘Year‘: 2018, ‘Month‘: 3, ‘Day‘: 18}
d.get(‘day‘)
d.get(‘hour‘,100)
# copy()    浅拷贝
new_d = d.copy()

# 3.增
# fromkeys    创建一个新字典，fromkeys(*args, **kwargs) 以*args中元素做字典的键，**kwargs为字典所有键对应的初始值
new_key = (‘Year‘, ‘Month‘, ‘Day‘)
dict1 = dict.fromkeys(new_d)
print("新的字典 : %s" % str(dict1))
dict1 = dict.fromkeys(new_d, 8)
print("新的字典 : %s" % str(dict1))

# 4.改
# setdefault    给字典设置(增加)新的键，存在就不设置(获取当前key对应的值)，不存在就设置并返回当前key对应的值
d1 = {‘Year‘: 2018, ‘Month‘: 3, ‘Day‘: 18}
v = d1.setdefault(‘hour‘,10)
print(d1,v)
# update    更新字典 update(self, E=None, **F),已存在的key就覆盖，不存在的key就添加进字典
d1 = {‘Year‘: 2018, ‘Month‘: 3, ‘Day‘: 18}
d1.update({‘Year‘: 2019, ‘Day‘: 20, ‘Hour‘: 10})
# d1.update(Year=2019, Day=20, Hour=10)

六丶集合

集合内的元素各不相同

集合是无序的

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

s = {1,2,3,4,5,6,7,8}

　　1.集合的运算

# 子集
a = set(‘abc‘)
b = set(‘cde‘)
c = set(‘ab‘)
c < a   # c 是 a 的子集
c.issubset(a)

# 并集
d = a | b
d = a.union(b)
print(d)
# 交集
e = a & b
e = a.intersection(b)

# 差集
f = a - b   # a 与 b 的差集
f = a.difference(c)
# 对称差
g = a ^ b
a.symmetric_difference(b)

　　2.集合的方法

add                     向集合中添加元素
clear                   清空集合
copy                    返回集合的浅拷贝
pop                     删除并返回任意的集合元素(如果集合为空，会引发 KeyError)
remove                  删除集合中的一个元素(如果元素不存在，会引发 KeyError)
discard                 删除集合中的一个元素(如果元素不存在，则不执行任何操作)
intersection            将两个集合的交集作为一个新集合返回
union                   将集合的并集作为一个新集合返回
difference              将两个或多个集合的差集作为一个新集合返回
symmetric_difference    将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)
update                  用自己和另一个的并集来更新这个集合
intersection_update()   用自己和另一个的交集来更新这个集合
isdisjoint() 　         如果两个集合有一个空交集，返回 True
issubset()　            如果另一个集合包含这个集合，返回 True
issuperset()            如果这个集合包含另一个集合，返回 True
difference_update()     从这个集合中删除另一个集合的所有元素
symmetric_difference_update() 用自己和另一个的对称差来更新这个集合

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

七丶运算符

a =10, b = 20

　　算术运算符

 　　比较运算符

　　赋值运算符

　　位运算符

　　逻辑运算符

 　　成员运算符

　　身份运算符

　　运算符优先级

　　更多：https://www.runoob.com/python/python-operators.html