python基础之数字、字符串、列表、元组、字典

Python基础二：

1、运算符：

判断某个东西是否在某个东西里面包含：

in  为真

not in  为假

（1）、算术运算符：

运算符	描述	实例
+	加  表示两个对象相加	a + b输出结果30
-	减  表示一个数减去另一个数	a - b输出结果-10
*	乘  两个数相乘或是返回一个被重复若干次的字符串	a * b输出结果200
/	除  两个数相除	b / a 输出结果2
**	幂  返回一个数的n次幂	3 ** 3 输出结果27
%	取余  返回除法的余数	b % a 输出结果 0
//	去整数  返回商的整数部分	9 // 2输出结果4

（2）比较运算

运算符	描述	实例
==	等于  比较对象是否相等	a == b返回False
!=	不等于 比较两个对象是否不相等	a != b 返回True
<>	不等于 比较两个对象是否不相等	<> 和== 意思一样（不推荐使用）
>	大于 一个值大于一个值	a > b 返回False
<	小于 一个值小于一个值	a < b 返回True
>=	大于等于 一个值大于等于一个值	a >= b 返回False
<=	小于等于 一个值小于等于一个值	a <= b 返回True

（3）赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b将a + b 结果赋值给c
+=	加法赋值运算符	c += a 等同于c = c + a
-=	减法赋值运算符	c -= a 等同于c = c - a
*=	乘法赋值运算符	c *= a 等同于c = c * a
/=	除法赋值运算符	c /= a 等同于c = c / a
%=	取模赋值运算符	c %= a 等同于c = c % a
**=	幂赋值运算符	c **= a 等同于c = c ** a
//=	取整数商赋值运算符	c//=a 等同于c = c // a

（4）逻辑运算符

运算符	描述	实例
and	布尔”与”-如果x为False，x and y返回False否则它返回y的计算值	（a and b）返回true
or	布尔”或”-如果是true,它返回True，否则它返回y的计算值	（a or b）返回True
not	布尔”非”-如果x为True，返回False，如果x为False，它返回True	not（a and b）返回false

2、基本数据类型

数字   -->  int  数字的所有的功能都在int里面

int 将字符串转换为数字

a="123"
print(type(a))   // type查看输出内容的类型
b=int(a)
print(type(b))

结果：

num='a'
s=int(num,base=16)  // base=16表示用把a用16进制转换为10进制
print(s)

结果：

bit_lenght   当前数字的二进制是用几位数组成，就显示几

num = 3
s=num.bit_length()   // bit_length()表示当前数字的二进制是几位数组成
print(s)

结果：

字符串 -->  str 字符串的所有的功能都在str里面

capitalize()   让当前字符串的首字母大写

test = "xyy"
n=test.capitalize()  // xyy的首字母变成大写
print(n)

结果：

lower()   让字符串里的大写字母变小写

test = "xYy"
n1 = test.lower()    // 把字符串里的大写字母变成小写的字母
print(n1)

结果：

center(20,"*")  20表示加上字符串一共有20位，*号表示填补空白的位，这里可以是任意的单一字符

test = "xyy"
n1 = test.center(20,"*")  // 加上字符串的长度一共是20位，空白处用*号填充
print(n1)

结果：

ljust(20,'*') 把字符串左移，并在右边添加字符填补空白

test = "xyy"
n = test.ljust(20,'*')  // 在xyy的右边添加20个*号
print(n)

结果：

rjust(20,'*')  字符串右移，并在左边添加字符填补空白

test = "xyy"
n = test.rjust(20,'*')  // 在xyy的左边添加20个*号
print(n)

结果：

count()  计算变量里面的字符的个数，有几个就输出几，没有就输出0

test="xyyxyy"
n=test.count('y')  // 上面字符串中的y有几个
print(n)

结果：

如果在count里面写一个变量里面没有的：

test="xyyxyy"
n=test.count('s')  // s在字符串里面没有
print(n)

结果：

在count里面在加上一个开始和结束：

test="xyyxyy"
n=test.count('y',4,6)  // 表示从4开始找，到6结束
print(n)

结果：

endswith()  表示字符串中以什么结尾，则为真（true），不是的则为假（false）

test = "xyyxyp"
n = test.endswith('p')   // 以p结尾为True
print(n)

结果：

startswith()   表示字符串中以什么开头，有为真，没有为假

test = "xyyxyp"
n = test.startswith('x')   // 表示以x开头为True
print(n)

结果：

find()  表示从开始往后找要匹配的字符，找到第一个就不在往后找了，并输出第一个的位置

test = "xyyxyp"
n = test.find('y')   // 找到y后就不在往后找了，位置是从0开始算起
print(n)

结果：

test = "xyyxyp"
n = test.find('y',3,5)  // 3和5表示从第3的位置开始找，到第5位结束 如果找不到字符串里的内容是则返回一个‘-1’
print(n)

结果：

 

format()  格式化，将一个字符串中的占位符替换为指定的内容

test = "I am {name}"
n = test.format(name = 'xyy') // 把字符串中的{name}用xyy替换
print(n)

结果：

test = "I am {name},age {a}"
n = test.format(name = 'xyy',a = '100;')  // 后面可以加多个
print(n)

结果：

test = 'I am {name}, age {a}'
n = test.format_map({"name":'xyyx',"a":20})
print(n)

和上面的意思是一样的，只是书写格式不一样；

结果：

lstrip()   移除左侧空白

name = "   xyyP"
n = name.lstrip()   // 把变量里面左侧的空白都移走
print(n)

结果：

partition()  指定分割符，把字符串分割成前，中，后三部分

name = "woshiyigeren"
n= name.partition('i')  // 以l为分割符，分成三部分
print(n)

结果：

rpartition() 指定分割符，把字符串分割成前，中，后三部分

test = "woshiyigeren"
v = test.rpartition('i')  // 当字符串中有多个指定的分割符，则按字符串最后面的指定的分割符进行分割
print(v)

结果：

isalnum()   判断字符串是否都是数字或字母

est = "12312313"
n = test.isalnum()   // 字符串是数字或者字母都为真（true）
print(n)

结果：

或者：

test = "xyysadasd"
n = test.isalnum()
print(n)

结果：

isalpha()   判断字符串是否是字母，是字母为真（True）

test = "fsfssdsdas"
n = test.isalpha()    // 字母则为真，数字则为假
print(n) 

结果：

expandtabs() 用table键进行断句，不够一定值的用空格补全

test = "username\temaol\tpassword\nxyy\txyy@qq.com\t123123\nxyy\txyy@qq.com\t123123\nxyy\txyy@qq.com\t123123\n"
n = test.expandtabs(20)  // 取20个字符，不够用空格补全
print(n)

结果：

isdecimal() 判断字符串是否为数字

isdigit()   判断字符串是否为数字

test = "123123"
n = test.isdecimal()  // 判断123123是否为数字，但是自能判断单纯的数字
print(n)
n1 = test.isdigit()   // 比isdecimal()功能强大，可以判断特殊的数字
print(n1)

结果：

又或者：

test = "②"
n = test.isdecimal()
print(n)
n1 = test.isdigit()  //可以判断特殊的数字
print(n1)

结果：

isnumeric()  判断是否是数字，并且数字可以是特殊字符和中文数字

test = "四"
n = test.isnumeric()  // 判断只要是数字就为真
print(n)

结果：

" ".join()  让字符串以什么分割，双引号里面可以是任何字符

test = "xyyxyp"
n = " ".join(test)
print(n)

结果：

replace()  替换字符串中的任意字符，括号中输入要替换的值和被替换的值，用，号隔开

test = "xyyp"
test = test.replace('y','c') // 把字符串中的y替换为c
print(test)

结果：

根据索引打印出对应的字符

test = "xyyp"
n = test[3] // 根据索引打印出对应的字符
print(n)

结果：

upper()把字符串中所以的小写字母变成大写

test = "xyyp"
n = test.upper()
print(n

结果：

 布尔值 -->  bool 布尔值的所有功能都在bool里面

列表   -->  list   列表的所有功能都在list里面

1、列表的格式：如：xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]

2、列表中可以嵌套任何类型；

3、都是用中括号括起来的；

4、用，号分割每个元素；

5、列表中的元素可以是数字，字符串，列表，布尔值，等等所有的值；

7、列表算是一个集合，内部可以放置任何东西；

索引取值：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]

print(xyy[2])  // 从0开始，2表示第三位

结果：

切片取值：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]
print(xyy[3:6])  // 从>=3开始，到小于6的值都打印出来

结果：

循环取值：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]
for i in xyy:
     print(i)   // for循环取元素，i就表示列表名xyy

结果：

索引修改和删除：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]
xyy[1] = 300  // 1表示从0开始取第二个元素，然后修改成想要的元素
print(xyy)

结果：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]
del xyy[2]  //索引中的2表示从0开始取第三个元素，del是关键字，表示删除
print(xyy)

结果：

切片修改和删除：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]
xyy[0:2]=[100,300]  // 取大于等于0小于2的元素的范围
print(xyy)

结果：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]
del xyy[0:4]   // 删除大于等于0小于4的这个范围的元素
print(xyy)

结果：

in的使用：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]
n = "xyp" in xyy   // 表示字符串在列表里面则为真（True），没在则为假 （False）
print(n)

结果：

取到嵌套在列表里的列表的某个值：

xyy = [1,3,"xyp",["xyy",["das",123],2,4],"dasa","123"]
n = xyy[3][1][1]   // 第一个3表示取第二层列表，第二个1表示取第三层列表，最后的1表示取最终的元素
print(n)

结果：

字符串转换成列表：

xyy = 'alexdasdasa'
n = list(xyy)   // 因为list表示列表，所以字符串可以直接转换
print(n)

结果：

列表转换成字符串：（如果有数字的情况下）

xyy = [1,3,"xyy"]
s = ""
for i in xyy:    //  在列表里有数字的情况下就要自己写for循环进行转换
    s = s + str(i)
print(s)

结果：

列表转换成字符串：（只有字符串的情况下）

xyy = ["xyp","xyy"]
n = "".join(xyy)   // 使用join把列表里面的符号都替换成空的
print(n)

结果：

append()  追加，追加一个元素到列表的末尾

xyy = [1,2,4,7,3,55]
xyy.append(10)   // 追加一个10到列表
print(xyy)

结果：

clear()  清除，清空

xyy = [1,2,4,7,3,55]
xyy.clear()   // 清空整个列表
print(xyy)

结果：

count() 计算列表中的指定的元素有几个

xyy = [1,2,4,4,7,3,55]
n = xyy.count(4)  // 列表中的4有几个
print(n)

结果：

copy() 把列表整体拷贝一份

xyy = [1,2,4,4,7,3,55]
n = xyy.copy()  // 把整个列表拷贝一份
print(n)

结果：

extend() 括号里面要加一个可迭代的元素

xyy = [1,2,4,4,7,3,55]
xyy.extend("xyyp")
xyy.extend(["sdas"])
print(xyy)

结果：

index()  从左往右开始找指定的元素

xyy = [1,2,4,4,7,3,55]
n = xyy.index(4)  // 找元素4在列表的第几位
print(n)

结果：

insert() 往列表中插入元素

xyy = [1,2,4,4,7,3,55]
xyy.insert(0,100)  // 指定索引并插入元素
print(xyy)

结果：

pop()  删除列表元素

xyy = [1,2,4,4,7,3,55]
xyy.pop()   // 默认删除列表的最后一个元素
xyy.pop(5)  // 指定索引删除元素
print(xyy)

结果1：

结果2：

remove() 删除列表元素

xyy = [1,2,4,4,7,3,55]
xyy.remove(4)   // 指定列表中的某个元素进行删除
print(xyy)

结果：

reverse()  反向取列表元素

xyy = [1,2,4,4,7,3,55]
xyy.reverse()   // 用相反的结果展现当前列表
print(xyy)

结果：

sort()  对列表内容排序

xyy = [1,2,4,4,7,3,55]
xyy.sort()  //默认的是正向排序
print(xyy)

结果1：

sort(reverse=True) 反向排序

xyy = [1,2,4,4,7,3,55]
xyy.sort(reverse=True)  // 加上reverse表示反向排序
print(xyy)

结果：

PS：append和extend区别：

xyy = [1,2,4,4,7,3,55]
xyy.append(["daxia"])  // 输入一样的元素
xyy.extend(["daxia"])
print(xyy)

结果对比：

append追加的元素显示为["daxia"]，extend追加的元素是"daxia"，两者是不一样的

元组   -->  tuple 元祖的所有功能都在tuple里面

1、元组的格式：test = (11,"xyy",["dsz"],("xsz"),)

2、元组的一级元素不可被修改，删除，添加

通过索引查找元组的元素：

test = (11,"xyy",["dsz"],("xsz"),)
print(test[2])

结果：

通过切片查找元组的元素：

 test = (11,"xyy",["dsz"],("xsz"),)
 print(test[2:5])

 结果：

for循环打印元组元素：

test = (11,"xyy",["dsz"],("xsz"),)
for i in test:
       print(i)

结果：

修改元组里面列表的元素：

test = (11,"xyy",["dsz"],("xsz"),)
test[2][0] = "dssz"  // 2表示元组里面第三个元素，0表示元组第三个元素的第一个元素
print(test)

结果：

元组转换成列表：

test = (11,"xyy",["dsz"],("xsz"),["dsz"])
n = list(test)
print(n)

结果：

转换成字符串：

test = (11,"xyy",["dsz"],("xsz"),["dsz"])
s=""
for i in test:
    s = s + str(i)
print(s)

结果：

PS:如果元组里面没有数字的话，可以和上面一样只用join把元组转换成字符串

count() 查看元组里面有几个指定的元素

test = (11,"xyy",["dsz"],("xsz"),)
n = test.count(["dsz"])
print(n)

结果：

index()  查看元组里面指定的元素排在第几位

test = (11,"xyy",["dsz"],("xsz"),["dsz"])
n = test.index(["dsz"])
print(n)

结果：

字典   -->  dict   字典的所有功能都在dict里面

1、字典的格式：test = {"x1":"y1","x2":"y2"}。

2、字典里面每用逗号分割的是一对，叫做”键值对”。

3、字典里面的value值可以是字典，列表，字符串，数字，元组，布尔值等等。

4、字典里面的key值不能是字典，列表。

5、字典是无序的。

取某个key的value：

test = {"x1":"y1","x2":"y2","x3":[12,24,["xyy","123",(11,22)]],"x4":["xyyp",("one","two"),{"xy1":"yy1","xy2":133}]}
n = test['x1']
print(n)

结果：

取到其中的11：

test = {"x1":"y1","x2":"y2","x3":[12,24,["xyy","123",(11,22)]],"x4":["xyyp",("one","two"),{"xy1":"yy1","xy2":133}]}
n = test['x3'][2][2][0]
print(n)

结果：

删掉其中的某个key值：

test= {"x1":"y1","x2":"y2","x3":[12,24,["xyy","123",(11,22)]],"x4":["xyyp",("one","two"),{"xy1":"yy1","xy2":133}]}
del test['x3']
print(test)

结果：

删掉其中的xy1：

test= {"x1":"y1","x2":"y2","x3":[12,24,["xyy","123",(11,22)]],"x4":["xyyp",("one","two"),{"xy1":"yy1","xy2":133}]}
del test['x4'][2]["xy1"]
print(test)

结果：

for循环输出：

test= {"x1":"y1","x2":"y2","x3":[12,24,["xyy","123",(11,22)]],"x4":["xyyp",("one","two"),{"xy1":"yy1","xy2":133}]}
for i in test:    //默认for循环输出的只要当前的key
    print(i)

结果：

或者：

for i in test.keys():  // 和for循环默认的输出是一样的，keys()是字典自带的功能
   print(i)

结果：

 

for循环输出value值：

test= {"x1":"y1","x2":"y2","x3":[12,24,["xyy","123",(11,22)]],"x4":["xyyp",("one","two"),{"xy1":"yy1","xy2":133}]}
for i in test.values(): // 和keys()一样，values()都是字典再带的功能
   print(i)

结果：

for循环同时获取key和value:

test= {"x1":"y1","x2":"y2","x3":[12,24,["xyy","123",(11,22)]],"x4":["xyyp",("one","two"),{"xy1":"yy1","xy2":133}]}
for k,v in test.items():  // items()是取key和value，但是要指定接收的对象
   print(k,v)

结果：

copy()  和列表的copy是一个意思，都是全复制一份

test = {"x1":"y1","x2":"y2","x3":133}
n = test.copy()   // 拷贝当前字典
print(n)

结果：

clear()  和列表的clear一样，只是返回的结果不一样

test = {"x1":"y1","x2":"y2","x3":133}
n = test.clear()   // 清空当前的字典
print(n)

结果：

fromkeys() 可以传一个列表或者元组等等，这个功能和原来的字典是不发生关系的

test = {"x1":"y1","x2":"y2","x3":133}
n = test.fromkeys(["k1","k2","k3"])  // 传一个列表，或者是字符串和元组
print(n)

 结果：

或者：

n = test.fromkeys(["k1","k2","k3"],'xyy')  // 后面接着再传一个参数的话就相当于给这个字典传了一个固定的value
print(n)

结果：

get()  表示如果括号里取一个当前字典没有的key的话，不会报错，会直接返回一个None值

test = {"x1":"y1","x2":"y2","x3":133}
n = test.get('dadas')
print(n)

结果：

或者:

test = {"x1":"y1","x2":"y2","x3":133}
n = test.get('dadas','bucunzai')  // 后面在加一个值表示取的key不存在的话会返回后面的这个值
print(n)

结果：

 

pop()  删除一个指定的值，括号写key值

test = {"x1":"y1","x2":"y2","x3":133}
n = test.pop('x2')  // 删除x2的value，并在后面打印出删除的值
print(test,n)

结果：

popitem() 随机删除一个key

test = {"x1":"y1","x2":"y2","x3":133}
n = test.popitem()
print(test,n)

结果：

setdefault() 设置一个不存在的key和value，会添加到当前字典里面

test = {"x1":"y1","x2":"y2","x3":133}
n = test.setdefault('k4','123')
print(test,n)

结果：

update() update有两种使用方法，一是括号里面传字典，二是括号里面用赋值的形式传

test = {"x1":"y1","x2":"y2","x3":133}
test.update({"k4":123,"k5":"xyyp"})
test.update(x5=456,x6="123")
print(test)

结果：