190320运算符&数据类型

一、运算符

1、算术运算符

• + 加
• - 减
• * 乘
• / 除
• ** 平方
• // 整除
• % 取余

2、比较运算符

• == 等于
• > 大于
• < 小于
• <= 小于等于
• >= 大于等于
• != or <> 不等于

3、成员运算符

• in
• not in

name = "dongfei"
if "d" in name:  #not in
    print('OK')
else:
    print("ERROR")

4、逻辑运算符

• and
• or

user = 'dongfei'
passwd = '123456'
gender = 'M'
result = gender == "M" and (user == "dongfei" and passwd == "123456") #先计算括号内的
print(result)

5、赋值运算符

• =
• +=

二、基本数据类型

• 数字 int
• 字符串 str
• 布尔值 bool：FalseNone""()[]{}
• 列表 list
• 元组 tuple
• 字典 dict

1、数字的方法

• int() 转换成整型

a = "123"
b = int(a)  #将字符串转换为整型
print(type(b))  #查看对象的数据类型

a = "0011"
b = int(a, base=2)  #将a以2进制的方式转换为十进制
print(type(b))
print(b)

• bit_length() 当前数字的二进制至少用几位来表示

age = 10
r = age.bit_length()
print(r)

2、字符串的方法

1. 字符串不允许修改

• capitalize() 首字母大写

s4 = "admininad"
print(s4.find("in"))

• lower() 或 casefold() 将字符串中的大写字母转换为小写
• islower() 判断字符串是否为小写
• upper() 转换为大写
• isupper() 是否为大写
• swapcase() 大小写转换

s2 = "Dongfei"
print(s2.casefold())
print(s2.lower())
print(s2.islower())
print(s2.upper())
print(s2.isupper())
print(s2.swapcase())

• center(20,"#") 设置总宽度，将字符串居中，可指定填充内容
• ljust(20,"#") 右补全
• rjust(20,"#") 左补全
• zfill(20) 填充0

s2 = "Dongfei"
print(s2.center(20,"#"))  #######Dongfei#######
print(s2.ljust(20,"#"))  #Dongfei#############
print(s2.rjust(20,"#"))  ##############Dongfei
print(s2.zfill(20))  #0000000000000Dongfei

• count('i',5,7) 统计字符串中有几个i，范围第5个字符到第7个字符
• endswith('i') 判断字符串是否以i结尾
• startswith('d') 判断字符串是否以d开头

s3 = "dongfeiii"
print(s3.count('i',5,7))

print(s3.endswith('i'))
print(s3.startswith('d'))

• encode()
• decode()
• find() 在字符串中查找并获取子串的位置，如果找不到则返回-1
• index() 功能和find()相似，如果找不到则报错

s4 = "admininad"
print(s4.find("in"),7,8)
print(s4.index("in"))

• format() 将字符串中的占位符替换为指定的值
• format_map() 和format()功能相似，接收字典

s5 = 'i am {name}'
print(s5.format(name="dongfei"))
print(s5.format( **{"name":"dongfei"} ))
print(s5.format_map( {"name":"dongfei"} ))

s6 = 'i am {0}, age {1}'
print(s6.format("dongfei",18))

• isalnum()
• isalpha()
• isdigit()
• isdecimal()
• isnumeric()

s7 = "asdf9234"
print(s7.isalnum())  #是否是字母和数字
print(s7.isalpha())  #是否是字母
print(s7.isdigit())  #是否是数字
print(s7.isdecimal())  #是否是数字，包括类似②特殊的数字
print(s7.isnumeric())  #是否是数字，可以判断中文的"二"

• expandtabs(6) 将字符串6个分为一组，如果有 则占用此组内剩余的字符

s8 = "username	email	password
dongfei	dongfei@qq.com	123456"
print(s8.expandtabs(20))

• isidentifier() 是否是一个标识符

s9 = "_123"
print(s9.isidentifier())  #是否是一个标识符，数字、字母、下划线，不能单独数字

• isprintable() 是否存在不可显示的字符， ， 等

s11 = "ja	ck"
print(s11.isprintable())

• isspace() 判断是否为空字符串

s12 = "  "
print(s12.isspace())

• title() 将字符串转换标题
• istitle() 判断是否为标题

s13 = "this is a title"
s14 = s13.title()
print(s14,s14.istitle())  #This Is A Title True

• join() 字符串拼接

s15 = "床前明月光"
print("_".join(s15))  #床_前_明_月_光

• strip() 去除空格、 、 或者指定的字符，默认去空格

s16 = " dong fei "
print(s16.lstrip())
print(s16.rstrip())
print(s16.strip())
s17 = "dongfei"
print(s17.lstrip("d"))

• maketrans() 对应
• translate() 替换

s18 = "床前明月光，12345"
s19 = str.maketrans("12345","疑似地上霜")
print(s18.translate(s19))  #床前明月光，疑似地上霜

• partition("s") 分割，包括分割的元素
• split("s") 分割，不包括分割的元素
• splitlines(True) 根据换行符分割

s20 = "asdftestfdas"
print(s20.partition("s"))  #按照”s“做分隔符分割为三份，('a', 's', 'dftestfdas')
print(s20.rpartition("s"))  #('asdftestfda', 's', '')
print(s20.split("s"))  #['a', 'dfte', 'tfda', '']
print(s20.rsplit("s",2))  #['asdfte', 'tfda', '']

s21 = "qwer
lllsdf
sdfggf"
print(s21.splitlines(True))  #['qwer
', 'lllsdf
', 'sdfggf']  #保留换行符
print(s21.splitlines(False))  #['qwer', 'lllsdf', 'sdfggf']  #不保留换行符

• replace() 字符串替换

s24 = "dongfeidongfeidongfei"
print(s24.replace("dong","xi"))  #xifeixifeixifei
print(s24.replace("dong","xi",1))  #xifeidongfeidongfei

• 重点小结

1. join()
2. split()
3. find()
4. strip()
5. upper()
6. lower()
7. replace()

• 字符串索引和切片，通过下标获取字符串中的某一个字符

s22 = "dongfei"
print(s22[0])
print(s22[1])
print(s22[2])
print(s22[3])
print(s22[0:3])  #0 >=; 3 <  结果：don
print(s22[0:-1])  #-1表示最后一个  结果：dongfe

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] #逆序截取

• len() 可接收字符串(有几个字符)、列表(有几个元素)

print(len(s22))  #计算字符串占用多少字符

• 小试牛刀1

import time
s23 = "飞流直下三千尺，疑似银河落九天。"
index = 0
while index < len(s23):
    print(s23[index])
    index += 1
    time.sleep(1)

• 小试牛刀2

import time
s23 = "飞流直下三千尺，疑似银河落九天。"
for i in s23:
    print(i)
    time.sleep(1)

3、列表的方法

1. 列表中的元素可以被修改
2. 列表中的元素可以被删除
3. 列表中的元素可以是任何数据类型
4. 列表可以嵌套
5. 列表是有序的

• 列表的格式

li = ["dongfei", "M", 18, ["python", "linux"]]

• append() 追加元素

li = ["dongfei", "M", 18, "python", "linux"]
li.append("mysql")  #在最后追加一个元素
li.append([123,321])
print(li)

• 修改元素

li[0] = "jack"
li[1:2] = ["F", 19]

• copy() 浅拷贝

li = ["dongfei", "M", 18, "python", "linux"]
li2 = li.copy()
print(li)
print(li2)

• del 删除元素

del li[0]
del li[1:3]

• clear() 清空元素

li.clear()

• in 判断

print("dongfei" in li)
print("python" in li[3])

• for 循环

for item in li:
    print(item)

• 取嵌套列表中的元素

print(li[3][0])

• 字符串转换为列表

a = "abc123"
print(list(a))  #['a', 'b', 'c', '1', '2', '3']

• 列表转换为字符串

# 第一种方法
li = ["dongfei", "M", 18, "python", "linux"]
s1 = ""
for item in li:
    s1 += str(item)
print(type(s1), s1)

# 第二种方法，前提是列表中的元素都是字符串
# s2 = "".join(li)

• count() 计算元素出现的次数

li = ["dongfei", "M", 18, "python", "linux"]
print(li.count("linux"))

• extend() 扩展元素，参数为可迭代对象

li = [11,22,33,44]
li.extend([55,66])
print(li)  #[11, 22, 33, 44, 55, 66]

• index() 根据指定元素从左到右查找元素位置

li = ["dongfei", "M", 18, ["python", "linux"]]
print(li.index("M", 1, 3))

• insert() 在指定位置插入元素

li = ["dongfei", "M", 18, ["python", "linux"]]
li.insert(3, "mysql")
print(li)  #['dongfei', 'M', 18, 'mysql', ['python', 'linux']]

• pop() 删除元素

li = ["dongfei", "M", 18, ["python", "linux"], "mysql"]
print(li.pop(1))  #M
print(li)  #['dongfei', 18, ['python', 'linux'], 'mysql']

• remove() 删除元素

li = ["dongfei", "M", 18, ["python", "linux"], "mysql"]
li.remove("dongfei")
print(li)  #['M', 18, ['python', 'linux'], 'mysql']

• reverse() 将列表元素的位置反转

li = ["dongfei", "M", 18, ["python", "linux"], "mysql"]
li.reverse()
print(li)  #['mysql', ['python', 'linux'], 18, 'M', 'dongfei']

• sort() 排序

li = [3, 234 ,5, 556, 3234, 234, 557]
li.sort()  #[3, 5, 234, 234, 556, 557, 3234]
# li.sort(reverse=True)  #[3234, 557, 556, 234, 234, 5, 3]
print(li)

4、元组的方法

1. 元组的一级元素不可被修改
2. 元组不能增加、删除
3. 推荐最后加个","
4. 可迭代对象
5. 有序的

• 元组的定义

tu = (123, "dongfei", (22, "abc"), ["mysql", "python"], "linux",)
print(tu[1])  #dongfei
print(tu[2:4])  #((22, 'abc'), ['mysql', 'python'])

• 将元组转换为列表

tu = (123, "dongfei", (22, "abc"), ["mysql", "python"], "linux",)
li = list(tu)
print(li, type(li))

• count() 统计指定的元素在元组中出现几次
• index() 获取指定的元素在元组中的位置

tu = (123, "dongfei", (22, "abc"), ["mysql", "python"], "linux",)
print(tu.count("dongfei"))  #1
print(tu.index("dongfei"))  #1

5、字典的方法

1. 列表不能作为字典的key，但是元组可以作为字典的key
2. 可以做hash的数据类型就可以作为字典的key
3. key重复时保留最后一个
4. 布尔值也可以作key

• 定义

info = {
    "name": "dongfei",
    "age": 18,
    "skill": ["python", "linux", "mysql"]
}

print(info)
print(info["name"])  #dongfei
print(info["skill"][0])  #python

• 删除键值

info = {
    "name": "dongfei",
    "age": 18,
    "skill": ["python", "linux", "mysql"]
}
del info["age"]  #{'name': 'dongfei', 'skill': ['python', 'linux', 'mysql']}
del info["skill"][2]  #{'skill': ['python', 'linux'], 'name': 'dongfei', 'age': 18}
print(info)

• 字典的for循环
• info.keys()
• info.values()
• info.items()

info = {
    "name": "dongfei",
    "age": 18,
    "skill": ["python", "linux", "mysql"]
}

for item in info:  #默认循环所有的key
    print(item)

for item in info.keys():  #循环所有key
    print(item)

for item in info.values():  #循环所有value
    print(item)

for k,v in info.items():  #循环取所有key和value
    print(k, v)

• clear() 清空字典

• copy() 浅拷贝

• dict.fromkeys() 将可迭代对象生成字典，key为可迭代对象的元素

print(dict.fromkeys(["k1", 321, "abc"]))  #{321: None, 'k1': None, 'abc': None}

• 根据key获取值，key不存在时返回指定值，默认为None

info = {
    "name": "dongfei",
    "age": 18,
    "skill": ["python", "linux", "mysql"]
}
print(info.get("name"))  #dongfei
print(info.get("nono", "key不存在"))  #key不存在

• pop() 删除键值并返回
• popitem() 随机删除一个键值并返回

info = {
    "name": "dongfei",
    "age": 18,
    "skill": ["python", "linux", "mysql"]
}
v1 = info.pop("skill")
print(v1)  #['python', 'linux', 'mysql']
v2 = info.pop("nono", "key不存在")
print(v2)  #key不存在
print(info)  #{'age': 18, 'name': 'dongfei'}

• setdefault() 已存在，不设置，获取当前key的值；不存在，设置，获取设置后key的值

info = {
    "name": "dongfei",
    "age": 18,
    "skill": ["python", "linux", "mysql"]
}
print(info.setdefault("name", "maria"))  #dongfei
print(info.setdefault("new_name", "jack"))  #jack
print(info)  #{'age': 18, 'skill': ['python', 'linux', 'mysql'], 'new_name': 'jack', 'name': 'dongfei'}

• update() 更新键值

info = {
    "name": "dongfei",
    "age": 18,
    "skill": ["python", "linux", "mysql"]
}
info.update({"name": "jack", "age":21})  #{'name': 'jack', 'skill': ['python', 'linux', 'mysql'], 'age': 21}
info.update(name="jack", age=21)
print(info)

三、range()

• 基本用法

for item in range(0,10):  #1 ~ 9
    print(item)

• 步长

for item in range(0,10,2):  #0,2,4,6,8
    print(item)

• 打印字符串对应字符的下标

taohuaxi = "一座高桥隔着云烟出现，在岩石的西畔询问渔船。桃花整天随着流水流淌，桃源洞口在清溪的哪边？"
for item in range(len(taohuaxi)):
    print(item,taohuaxi[item])

四、常用方法总结

1. 数字

int

2. 字符串

replace
find
join
strip
startswith
endswith
split
upper
lower
format

3. 列表

append
extend
insert

4. 字典

get
update
keys
values
items