第七篇Python基本数据类型之数字&字符串&布尔值

数字

写在最前，必需要会的：int()

整型

Python3里不管数字多长都用int表示，Python2里有int和Long表示，Long表示长整型

有关数字的经常使用方法，方法调用后面都必须带括号()

int()：将字符串转换为整型，且字符串内容只能是数字

a = "123" b = "123a" c = int(a) d = int(b)       # ValueError: invalid literal for int() with base 10: '123a'
print(type(c)) print(type(d))

int(x,[base])：将x转换为整型，base指定转换的基数，base=2, 8, 16,表示以2,8,16进制转换，默认是10进制

e = "a" f = int(e, base=16) print(type(f)) print(f) #结果
<class 'int'>
10

bit_length()：当前数字用二进制表示时，至少有几位

age1 = 1 age2 = 2 age3 = 3 age4 = 4 age5 = 5 age6 = 6 age7 = 30
print(age1.bit_length()) print(age2.bit_length()) print(age3.bit_length()) print(age4.bit_length()) print(age5.bit_length()) print(age6.bit_length()) print(age7.bit_length()) #结果
1
2
2
3
3
3
5

字符串

写在最前，必需要会的：replace(),find(),join(),strip(),stratwith(),endwith(),split(),upper(),lower(),format()

format(self, *args, **kwargs)：格式化字符串

temp = "I am {name},age: {age}" v = temp.format(name = "alex",age = 19) print(v) # 若是方法的定义里有**kwargs,就表示 他能够写成name = x,也能够写成字典形式
v1 = temp.format(**{"name":"alex2","age":20}) print(v1) #结果
I am alex,age: 19 I am alex2,age: 20

 

总结

一、经常使用须要记住的字符串的基本魔法（7个）

join()、split()、find()、strip()、upper()、lower()、replace()

 

二、灰魔法（4个）

（1）、索引（下表）：从0开始的，也就是某个字符串的第一个字符的索引是0

test = "alex"
print(test[0]) #结果
a

（2） 切片

test = "alex"
print(test[0:2])   # 范围 0<=test[0:2]<2

#结果
al

（3）、len():获取当前字符串的长度，即由几个字符组成

print(len(test))

# 结果
4

test1 = "你好世界"
print(len(test1))

# 结果
4    （Python3）
9    （Python2.7）

# 若是len()的对象是列表，是以逗号为标记，得到有几个元素

li = ["adf","dfad","fadf","fad","re"]
print(len(li))

# 结果
5

（4）、将字符串里的每一个字符单独拿出来的两种方法

test = "他说妹子冲我来"
# 方法1：while 循环实现
 index = 0 while index < len(test): v = test[index] print(v) index = index + 1

# 方法2：for 循环实现
for count in test: print(count)

rnage(）：用来建立连续的数字

v = range(100) print(v)      # range(0, 100)

# 在python2.7里,range(100)在内存里当即就建立了，命令行里立马就打出0~99个数 # 在python3里，range(100)是在循环开始的时候才一个一个的建立内存 # 其实这是python3的一个优化，试想，若是又10000万个数，若是当即建立，内存占用会马上升高

range(0,100,step):能够经过设置步长，来建立不连续的数字

v = range(0, 100, 30)   #0 到100个数里，步长30，每一个30个数取一个
for i in v: print(i) #结果
30
60
90

#练习： 将test对应的字符串的索引和对应的字符打印出来
test = input(">>>") l= len(test) for item in range(l): print(item,test[item])

 

字符串一旦建立，就不能修改；可是一旦修改或者拼接，都会形成从新生成字符串，开辟新的内存

字符串的表示方法：经过引号表示

1 # 下面对字符串的表示都是正确的
2 str1 = '单引号'
3 str2 = "双引号"
4 str3 = '''三个单引号'''
5 str4 = """三个双引号"""
6 
7 # 注意：引号不能混用，好比
8 str5 = "引号不能混用，会报错'

 字符串的方法太多了，两种方式能够得到字符串都有哪些方法：

1. Pycharm等带有自动提示功能的编译器，写一个字符串，后面 点一下，就会提示它可用的方法

2. Pycharm里，安装Ctrl，鼠标光标移到 str()上，点击左键就会进入str()的方法，里面能够看到每种方法的具体定义

字符串的方法：

由于太多了，因此练一个写一个。

capitalize()：首字母大写

str1 = "alex" v = str1.capitalize() print(v) #结果
Alex

casefold():将字母变成小写
lower():将字母变成小写

test = "alex" v1 = test.casefold()   # 更牛逼，不少未知的对应关系也能够变小写
print(v1) v2 = test.lower()     # 对普通的，咱们能想到的变小写
print(v2)

#结果

　alex
　alex

center(self, width, fillchar=None):设置宽度，并将内容居中，width表示总长度，fillchar表示空白位置填充，能够用不填，要填只能填一个字符，表示空白位置用该字符填充。

对于方法里有参数的，调用的时候必须带参数，此方法里width对应的必须带个参数，而fillchar后面有=，默认值是None，对应这种参数有默认值的能够不带，

若是带了参数，fillchar就取写的值

test = "ALex" v3 = test.center(20) v4 = test.center(20,"国") print(v3) print(v4) #结果
 ALex  国国国国国国国国ALex国国国国国国国国

ljust():字符串左对齐，其他宽度用指定字符填充

rjust():字符串右对齐，其他宽度用指定字符填充

zfill():默认只能用0填充，不能指定填充字符

test = "alex" v = test.ljust(20,"*")  # 字符串左对齐，其他宽度用指定字符填充
print(v) v1 = test.rjust(20,"￥")   # 字符串右对齐，其他宽度用指定字符填充
print(v1) v2 = test.zfill(20)   # 默认只能用0填充
print(v2) # 结果
alex**************** ￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥alex 0000000000000000alex

count(self, sub, start=None, end=None)：去字符串中寻找子序列（子字符）出现的次数，start:表示开始查找的位置，end:表示查找结束的位置

 1 test = "ALexalexr"
 2 v = test.count("ex")  3 print(v)  4 
 5 v1 = test.count("ex",5,6)  6 print(v1)  7 
 8 #结果
 9 2
10 0

string.encode(encoding='UTF-8', errors='strict')：以 encoding 指定的编码格式编码 string，若是出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

 

endswith(self, suffix, start=None, end=None)：表示以什么什么结尾，返回值是布尔值

test = "ALexalexr" v1 = test.endswith("r") v2 = test.endswith("xr",4,6) print(v1) print(v2) #结果
True False

startswith(self, suffix, start=None, end=None)：表示以什么什么开始，返回值是布尔值

test = "ALexalexr" v1 = test.startswith("ALe") v2 = test.startswith("a",4,6) print(v1) print(v2) #结果
True True

 find()：从开始日后寻找，找到第一个匹配字符后，返回它的索引位置

test = "alexalex" v = test.find("ex") print(v) #结果
2

find(self, suffix, start=None, end=None)：start表示起始寻找的位置，end表示结束寻找的位置  [start,end)

v1 = test.find("ex", 5, 7) print(v1) v2 = test.find("ex", 5, 8) print(v2) #结果
-1 表示没有找到 6 结论：[start, end) 左闭右开区间

index():寻找字符在字符串中是否存在，并返回位置索引值

test = "alexalex" v = test.index("ex") print(v) v1 = test.index("8") print(v1)      # 没有找到，直接就程序报错了。

# 结论
find()找到后返回的也是位置索引，index()也是返回位置索引，可是find()找到不到的时候返回-1，index()找不到的时候程序报错，因此，实践中经常使用find()

format(): 格式化，将一个字符串中的占位符替换为指定的值，有两种方式：

1. format()里经过指定name 和 a 的对应的具体的值进行格式化

test = "I am {name}, age {a}"   # {name},{a}是占位符
print(test) v = test.format(name = "alex", a = 19) print(v) #结果
I am {name}, age {a} I am alex, age 19

2. format()里不指定具体的占位符对应的值，就会按照占位符的顺序进行替换

test = "I am {0}, age {1}"
print(test) #结果
I am {0}, age {1} v = test.format("alex", 19) print(v) #结果
I am alex, age 19

format()三种方法更直观的示例：
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

format_map()：格式化，传入的值是按字典的键值对方式传入的，其功能与format同样

test = "I am {name}, age {a}" v3 = test.format_map({"name":"alex", "a":19}) print(v3) #结果
I am alex, age 19

 isalnum()：判断字符串中是否只包含 字母和数字，若是还包含其余字符，返回FALSE，只有数字或字母，返回TURE

test = "alexalex898_+"
print(test.isalnum()) test = "alexalex898_"
print(test.isalnum()) test = "alexalex898"
print(test.isalnum()) #结果
False False True

 isalpha()：判断字符串中是否只包含 字母，若是还包含其余字符，返回FALSE，只有字母，返回TURE

test = "adfad"
print(test.isalpha()) test1 = "adfad2"
print(test1.isalpha()) #结果
True False

 expandtabs():断句，能够制做表格，以下示例：

以20个字符为一组进行断句，若是没有满20个字符，就遇到了\t, 剩下的字符\t自动会以空格补齐。

好比，username是8个字符，就遇到了\t, 还差12个字符才够20个一组，因此剩下12个字符就以12个空格补齐

test = "username\temail\tpassword\nlaiying\tlaying@163.com\t78749798\nlaiying\tlaying@163.com\t1234567"

print(test.expandtabs(20)) #结果
username email password laiying laying@163.com      78749798 laiying laying@163.com      1234567

isdecimal()：判断当前字符串输入的是否为数字
isdigit()：判断当前字符串输入的是否为数字，也能够判断其余形式的数字，而isdecimal()则不能够

isnumeric()：判断字符串是不是数字，能够判断中文，特殊符号的数字

test = "123"
print(test.isdecimal())  # True
print(test.isdigit())    # True
print(test.isnumeric())  # True
 test1 = "②"
print(test1.isdecimal())  # False
print(test1.isdigit())    # True
print(test1.isnumeric())  # True
 test2 = "二"
print(test2.isdecimal())  # False
print(test2.isdigit())    # False
print(test2.isnumeric())  # True

swapcase()：大小写字母转换

test = "alex" print(test.swapcase()) # ALEX  test1 = "AlsdR" print(test1.swapcase()) # aLSDr

isidentifier()：判断标识符的起名是否符合规范，符合返回TRUE，不符合返回FALSE

标识符起名，以字母，数字，下划线组成，可是开通不能是数字

a1 = "jakd_87943" a2 = "87943jakd_"
print(a1.isidentifier())  # True
print(a2.isidentifier())  # False

isprintable()：是否存在不可显示的字符

\t:表示制表符

\n:表示换行

test = "fadjajk"
print(test.isprintable())  # True
 test1 = "fadjajk\nfjakdjf" test2 = "fadjajk\tadfd"
print(test1.isprintable())  #False
print(test2.isprintable())  #False

isspace()：判断是否所有字符串都是空格。 即判断是否为空字符串

test = "fadjajk"
print(test.isspace())     # False
test1 = "      " 
print(test1.isspace())    # True

istitle()：判断是否为标题

title()：将字符串变成标题

# 标题的首字母都是大写的
test = "Return True if all cased chakd"
print(test.istitle())  # False

#将字符串变成标题，全部首字母都大写
print(test.title())    # Return True If All Cased Chakd

join()： 将字符串中的每个元素按照指定分割符进行拼接  ※※※※※重要※※※※※

Join()的内部原理实际上是循环字符串，找到一个字符串就加上指定的分隔符，再去循环下一个

test = "你是风儿我是沙"
# 想把上面的字符串都用空格隔开
t = " " v = t.join(test) print(v)    # 你 是 风 儿 我 是 沙
print("++".join(test))  # 你++是++风++儿++我++是++沙

a = "hello" c = " " b = "world"

print("888".join([a,b]))             # hello888world
print("888".join([a,b, "新家"]))      # hello888world888新家

islower()：判断字符串是否所有为小写

lower()：将全部字母转换成小写

用法：不区分大小写能够用的方法

test = "Alex"
print(test.islower())   # False
print(test.lower())     # alex

isupper()：判断字符串是否所有为大写

upper()：将全部字母转换成大写

v1 = test.isupper() v2 = test.upper() print(v1)    # False
print(v2)    # ALEX

swapcase()：大小写字母转换

test = "dajlkjdfakdDSFSSWDSdlfja;ldkfjfajdkfja"
print(test.swapcase()) #结果 DAJLKJDFAKDdsfsswdsDLFJA;LDKFJFAJDKFJA

lstrip() ：默认去除字符串左边的空白、去除\n , \t ，若是指定去除字符的时候，连左边的全部空白和指定字符都去除掉了

rstrip() ：去除字符串左边的空白

strip() ：去除字符串左右两边的空白

test = " Alex " v1 = test.lstrip()  # 去除字符串左边的空白
v2 = test.rstrip()  # 去除字符串左边的空白
v3 = test.strip()   # 去除字符串左右两边的空白
print(v1) print(v2) print(v3) # 结果
Alex Alex Alex

test1 = " \nalex " test2 = " alex\t "

print(test1.lstrip())          # 去除\n
print(test2.rstrip())         # 去除 \t
 test3 = "alexed"
print(test3.lstrip("al"))    # 指定字符去除

test = "xaexlex" v = test.rstrip('9lexxexa') print(v) # 移除指定字符 # 遵循最多匹配 # 上面用的是从右开始往左找
1. lex有，test里就移除掉lex,而后ex也有，test就再移除ex,一样还有xa，也能够移除

maketrans():建立对应关系

translate()：执行替换

maketrans()老是与translate()一块儿用

# test 和 test1 字符个数必须上下对应 # 而后将v里的字符进行替换，即v里若是发现你，就用1替换，返现是就用2替换
 test = "你是风儿我是沙" test1 ="1234567" v = "你是风儿我是沙，缠缠绵绵去你家" m = str.maketrans("你是风儿我是沙","1234567")  # 1. 先建立对应关系
new_v = v.translate(m)  # 2. 再根据对应关系进行替换
print(new_v) #结果
1634567，缠缠绵绵去1家

字符串分割的方法：

partition()：指定分割字符，永远只能分割三份

rpartition()：指定分割字符，永远只能分割三份，从右边开始找并进行分割

partition()分割后，指定的分割字符本身能够拿获得，而split()指定的分割字符本身是拿不到的

split(self, sep=None, maxsplit=-1)：指定分割字符，maxsplit默认为不指定分割次数，有几个分割字符就分割几回。 指定3，就最大分割三次

rsplit(self, sep=None, maxsplit=-1)：同上，只是从右边开始查找分割

后面还会介绍一个正则表达式，也能进行字符串分割

# 字符串分割
test = "testasdfjfadssddfd"
# 按自定字符串进行分割，找到第一个匹配字符就能够进行分割 # 若是能分割，永远只能分割为三份
print(test.partition("s"))    # ('te', 's', 'tasdfjfadssddfd')

# 从右边开始找，找到第一个指定字符后，开始分割，永远只能分割为三份
print(test.rpartition("s"))  # ('testasdfjfads', 's', 'ddfd')

# 根据指定字符进行分割，并且能够指定分割的个数，想分几个分几个 # split()有个弊端, 指定的分割字符匹配到后，本身拿不到
print(test.split("s"))  # ['te', 'ta', 'dfjfad', '', 'ddfd']
print(test.split('s',1))   # ['te', 'tasdfjfadssddfd']
print(test.split('s',2))   # ['te', 'ta', 'dfjfadssddfd']

# 从右开始找
print(test.rsplit('s',3))  # ['testa', 'dfjfad', '', 'ddfd']

splitlines(self, keepends=None)：按照换行符\n进行分割，默认不保留换行符

test = "dajlkjdfakdjfa\nfjadlfja;ldkfj\nfajdkfja"
print(test.splitlines()) print(test.splitlines(True)) # True 表示 分割后保留换行符 print(test.splitlines(False)) # False 表示 分割后不保留换行符 # 结果
['dajlkjdfakdjfa', 'fjadlfja;ldkfj', 'fajdkfja'] ['dajlkjdfakdjfa\n', 'fjadlfja;ldkfj\n', 'fajdkfja'] ['dajlkjdfakdjfa', 'fjadlfja;ldkfj', 'fajdkfja']

startswith(self, prefix, start=None, end=None)：判断字符串是否以某某字符开头，start 和 end 参数表示开始和结束的位置

endswith(self, suffix, start=None, end=None)：判断字符串是否以某某字符结尾，start 和 end 参数表示开始和结束的位置

test = "dajlkjdfakdjfa\nfjadlfja;ldkfj\nfajdkfja"

print(test.startswith("da")) print(test.startswith("a")) print(test.endswith("ja")) print(test.endswith("j")) # 结果：
True False True False

 replace(self, old, new, count=None)：替换字符串，old是要被替换的字符，new是替换字符， count是几，表示就替换前面几个

test = "alexalexalexalex"
print(test.replace("ex","bbbb")) print(test.replace("ex","bbbbb", 2)) #结果
albbbbalbbbbalbbbbalbbbb albbbbbalbbbbbalexalex

关于字符串两个练习

# 1. 将输入的下划线风格转驼峰风格
 data = input("请输入一个带有下划线风格的变量名： ") words = data.split("_")  # 首先，以_进行分割，获得一个个独立的单词，是个列表
result =""
for word in words： result += word.capitalize() # 而后将每一个单词的首字母大写，再利用字符串运算符+拼接字符串
print(result) # 2. # 写一个脚本解析url http://localhost:8080/test/data?abc=def&test=debug，获得协议，host,端口号，路径。参数

# 首先解析要注意，两个冒号解析的话，可能会越解析越乱，因此，先以?来分割
a = url1.split("?") # 直接就能够获得参数了 # print(a) # ['http://localhost:8080/test/data', 'abc=def&test=debug']

# 而后再以:来分割
b = a[0].split(":") # print(b) # ['http', '//localhost', '8080/test/data'] # 能够获得协议了
print("protal:{}".format(b[0])) # 再处理获得host
print("host:{}".format(b[1].split("//")[1])) # 以"/"分割，拿到端口，并拼接path
c=b[-1].split("/") # 注意，有些url是没有端口的，因此就须要有异常处理或者判断
try: d = int(c[0]) print("port:{}".format(d)) except Exception as error: print("port:{}".format("not port in this url")) print("path:{}{}".format("/", "/".join(c[1:]))) print("parameter: {}".format(a[-1]))

View Code

Python字符串运算符

 

操做符	描述	实例
+	字符串链接	>>>a + b 'HelloPython'
*	重复输出字符串	>>>a * 2 'HelloHello'
[]	经过索引获取字符串中字符	>>>a[1] 'e'
[ : ]	截取字符串中的一部分	>>>a[1:4] 'ell'
in	成员运算符 - 若是字符串中包含给定的字符返回 True	>>>"H" in a True
not in	成员运算符 - 若是字符串中不包含给定的字符返回 True	>>>"M" not in a True
%	格式字符串	请看下一章节

# 示例
 a = "hello" c = " " b = "world"

print(a+c+b) # hello world 
print(50 * "=") # ==================================================
print(len(a)) # 5

print(a[2]) # l

print(a[1:-1]) # ell

print(a[:]) # hello

print("l" in a) # True

print("a" not in a) # True

 

Python字符串转义

在须要在字符中使用特殊字符时，python用反斜杠(\)转义字符。以下表： 

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy表明的字符，例如：\o12表明换行
\xyy	十六进制数，yy表明的字符，例如：\x0a表明换行
\other	其它的字符以普通格式输出

布尔值

后面还有，12以前的某个课程里讲的，要补课

 写在最前：

1. 转换： bool([])

2. 布尔值自己就是0 和 1

3.特殊状况，哪些是假？

None，空字符串，空字典，空列表，空元组，0，空集合  这几个用布尔值判断的时候都是False，其余都是真

print(bool(["dfjdak","fad"])) print(bool([])) #结果
True False