3. Python开发【第三篇】：基本数据类型（数字、字符串）-2020.11.05

一、python开发的IDE:
　　1.pycharm(安装之后不需要再装任何额外的插件)、eclipse(安装之后需要装很多额外的插件)；
　　2.pycharm需要安装专业版的，不要汉化否则有些功能无法使用；
　　3.基本操作：创建文件夹（创建新Directory），创建python文件（创建新Python File），运行（方式4种）；
　　修改字体大小写（2种：Settings-Font-size;通过Ctrl+滑动鼠标调整字体大小）；
　　在pycharm中直接找到PC上对应放置的python文件（选中，右键选择show in Explorer）；
　　显示行号（点击目录和代码之间的地方，右键选择Show Line Numbers）；
　　部分代码一起注释掉或去掉注释（选中-Ctrl+?或/）；

二、运算符
　　1.+ - * / //（取商） %（取余） **（次方）
　　2.in not in #判断某个东西是否在某个东西里面包含
　　name = "郑建文"
　　"郑建文" #是一个字符串，其中郑是其中的一个字符，一个汉字是一个字符
　　“郑” 、“建文” #是子字符串或子序列

if “建文” in nane:
    print('OK')
else:
    print(''Error)
        
if “建文” in nane:
    print('OK')
else:
    print(''Error)
            
if "郑文" not in name:
    print('1')
else:
    print('2')

　　in和not in的结果是布尔值
　　　　1.== > < >= <= !=（不等于） <>（不等于） v = not False（非），的结果也是布尔值
　　　　2.注意：布尔值有2个值，True（真） False（假）

if True：
    pass
while True:
    pass

 

三.不同运算的结果类型不同
　　结果是数值:
　　　　算术运算：a = 10 * 10
　　　　赋值运算：a = a + 1 a+=1
　　结果是布尔值：
　　　　比较运算：a = 1 > 5
　　　　逻辑运算：a = 1 > 6 or 1 == 1
　　　　成员运算：a = "蚊" in “郑建文”
　　补充：逻辑运算
　　　　执行顺序：先计算括号里面的，从前到后
　　　　　　结果：
　　　　　　　　True OR ==>True
　　　　　　　　True AND ==>继续走
　　　　　　　　False OR ==>继续走
　　　　　　　　False AND ==>False
　　　　例：user = “alex”
　　　　　　pwd = “123”
　　　　　　v = not False (True)
　　　　　　v = user == “alex” or pwd == “123” (True)
　　　　　　v = user == “alex” and (pwd == “123” or 1 == 2) (True)
　　　　　　v = user == "alex" and pwd == "1234" or 1 == 1 and pwd == "99854" and 1 == 2 (False)
　　　　　　print(v)

四. 基本数据类型

　　① 数字 int ，所有的功能，都放在int里
　　　　a1 = 123
　　　　a2 = 456
　　- int
　　将字符串转换为数字

a = "123"
print(type(a),a)  #<class 'str'> 123

b = int(a)
 5 print(type(b),b) 6 
num = "0011" 
v = int(num, base=16)  #base是按照n进制输出，按照16进制（0-9，a,b,c,d,e,f,其中a对应的是10）输出是17（16的0次方+16的一次方），按照10进制输出是11，按照2进制输出是3；
print(v)

　　当前数字的二进制，至少用n位表示

num = "0011"
v = int(num, base=16)
print(v)               #17
r = v.bit_length()     #当前数字的二进制，至少用n位表示
print(r)               #5(备注17用二进制表示是10001)

 

② 字符串 str

################################################

1 首字母大写（只将首字母大写，其它的全部都小写，无论之前是大写还是小写）

test = "aLex"
v = test.capitalize()
print(v)     #输出Alex

2 所有变小写，casefold更牛逼，很多未知的对相应变小写

str1 = "I Love Python"
str2 = "Groß - α" #德语
print(str1.casefold())     #输出i love python
print(str1.lower())        #输出i love python
print(str2.casefold())     #输出gross - α，casefold()可将特殊的大写字母转换为小写字母
print(str2.lower())        #输出groß - α，lower()不能将德语的大写字母转换为小写字母

3 设置宽度，并将内容居中

# * 空白未知填充，一个字符，可有可无
test = "aLEX"
v = test.center(20,"中")  #20 代指总长度
print(v)                  #输出中中中中中中中中aLEX中中中中中中中中

 

test = "alex"                #左靠齐
v = test.ljust(20,"*")       #输出alex****************
print(v)                     

test = "alex"                #右靠齐
v = test.rjust(20,"*")       #输出****************alex
print(v)

test = "alex"                #默认右靠齐，用0填充
v = test.zfill(20)           #输出0000000000000000alex
print(v)

4 去字符串中寻找，寻找子序列的出现次数

test = "aLexalexr"
v = test.count('ex')     #输出2，'ex'出现2次
print(v)

test = "aLexalexr"
v = test.count('ex',5,6) #输出0，范围start=5，end=6，从0开始
print(v)

# 欠
# encode
# decode

5 以什么什么结尾，以什么什么开始

test = "alex"
v = test.endswith('ex')        #True
v = test.startswith('ex')      #False
print(v)

6 expandtabs,断句20

test = "username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123"
v = test.expandtabs(20)     #以20断句，\t分隔符，\n换行
print(v)

username            email               password
laiying             ying@q.com          123
laiying             ying@q.com          123
laiying             ying@q.com          123

7 从开始往后找，找到第一个之后，获取其位置

test = "alexalex"
v = test.find('ex')      #输出2；未查找到时输出-1；从开始往后找，找到第一个之后，获取第一个字符的位置，并停止查找；
print(v)

8 index输出相关字符的索引，找不到字符，报错

test = "alexalex"
v = test.index('e')     #输出2，从开始往后找，找到第一个后，获取其索引位置，并停止查找；未找到时，报错；
print(v)

9 格式化，将一个字符串中的占位符替换为指定的值

test = 'i am {name}, age {a}'
print(test)                             #i am {name}, age {a}
v = test.format(name='alex',a=19)
print(v)                                #i am alex, age 19

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

10 格式化，传入的值 {"name": 'alex', "a": 19}

test = 'i am {name}, age {a}'
v1 = test.format(name='df',a=10)
v2 = test.format_map({"name": 'alex', "a": 19})
print(v1,v2)       #输出i am df, age 10 i am alex

11 字符串中是否只包含 字母和数字

test = "123abc"
v = test.isalnum() #alphabet字母，number数字
print(v)           #True
test = "123abc@"
v = test.isalnum()
print(v)           #False

12 字符串中是否只包含 字母，汉字

test = "as2df"
v = test.isalpha()    
print(v)              #输出False

test = "as国df"
v = test.isalpha()
print(v)              #输出True

13 当前输入是否是数字

num = "1"  #unicode
v1 = num.isdigit()   # True
v2 = num.isdecimal() # True
v3 = num.isnumeric() # True
print(v1,v2,v3)

num = "1" # 全角
v1 = num.isdigit()   # True
v2 = num.isdecimal() # True
v3 = num.isnumeric() # True
print(v1,v2,v3)

num = b"1" # byte
v1 = num.isdigit()   # True
v2 = num.isdecimal() # AttributeError 'bytes' object has no attribute 'isdecimal'
v3 = num.isnumeric() # AttributeError 'bytes' object has no attribute 'isnumeric'
print(v1,v2,v3)

num = "②" # 非普通数字字符②
v1 = num.isdigit()   # True
v2 = num.isdecimal() # False
v3 = num.isnumeric() # True
print(v1,v2,v3)

num = "四" # 汉字数字、罗马数字Ⅳ
v1 = num.isdigit()   # False
v2 = num.isdecimal() # False
v3 = num.isnumeric() # True
print(v1,v2,v3)

isdecimal()，如果字符串是否只包含十进制字符返回 True，否则返回 False；

isdigit()，如果字符串只包含数字则返回 True 否则返回 False；

isnumeric()，如果字符串中只包含数字字符，则返回 True，否则返回 False。

isdigit()

True: Unicode数字，byte数字（单字节），全角数字（双字节），非普通数字字符②

False: 汉字数字、罗马数字

Error: 无

isdecimal()

True: Unicode数字，，全角数字（双字节）

False: 罗马数字，汉字数字、非普通数字字符②

Error: byte数字（单字节）

isnumeric()

True: Unicode数字，全角数字（双字节），罗马数字，汉字数字、非普通数字字符②

False: 无

Error: byte数字（单字节）

14 是否存在不可显示的字符

#如果字符串中的所有字符都是可打印的字符或字符串返回 True，否则返回 False。
test = "oiuas\tdfkj"       #\t 制表符,\n 换行符不可打印（不可显示）
v = test.isprintable()
print(v)                   # 制表符 False

15 判断是否全部是空格

test = ""
v = test.isspace()   #字符串中，全是空格返回True;
print(v)             #无空格，输出False
test = " a"
v = test.isspace()
print(v)             #有空格，但不全是空格，输出False
test = " "
v = test.isspace()
print(v)             #只有空格，输出True

16 判断是否是标题

test = "Return True if all cased characters in S are uppercase and there is"
v1 = test.istitle()   #是标题（所有的首字母大写），返回 True，否则返回 False；
print(v1)             #输出False
v2 = test.title()
print(v2)             #输出Return True If All Cased Characters In S Are Uppercase And There Is
v3 = v2.istitle()
print(v3)             #输出True

17 ***** 将字符串中的每一个元素按照指定分隔符进行拼接

test = "你是风儿我是沙"
print(test)             #输出你是风儿我是沙
v = "_".join(test)
print(v)                #输出你_是_风_儿_我_是_沙

18 判断是否全部是大小写 和 转换为大小写

test = "Alex"
v1 = test.islower()
v2 = test.lower()
print(v1, v2)       #输出False alex

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

19 移除指定字符串,有限最多匹配

 想去掉字符串里面的哪些字符，那么就把这些字符当参数传入，此函数只会删除头和尾的字符，中间的不会删除，

 如果strip()的参数为空，那么会默认删除字符串头和尾的空白字符(包括空格，\t，\n，\r（回车）这些)；

test = "\t\n\r   fexax   \t\n\r"
v1 = test.lstrip()       #输出fexax       ，去除左端的空白\t \n
v2 = test.rstrip()       #输出   fexax，去除右端的空白\t \n
v3 = test.strip()        #输出fexax，去除左右两端的空白\t \n
print(v1,v2,v3)

# 有限最多匹配(可单个匹配，可多个匹配)
test = "fexax"
v1 = test.lstrip('xa')           #输出fexax
v2 = test.rstrip('9lexxexa')     #输出f
v3 = test.strip('xa')            #输出fe
print(v1,v2,v3)

20 对应关系替换

test = "aeiou"
test1 = "12345"
v = "asidufkasd;fiuadkf;adfkjalsdjf"
m = str.maketrans("aeiou", "12345")
#用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
#第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标;
#两个字符串的长度必须相同，为一一对应的关系(如a被转换为1)。
new_v = v.translate(m)
print(new_v)                  #输出1s3d5fk1sd;f351dkf;1dfkj1lsdjf

21 分割为三部分

#这两个函数都接收一个分割字符串作为参数，将目标字符串分割为两个部分，返回一个三元元组（head,sep,tail），包含分割符。
#细微区别在于rpartition从目标字符串的末尾也就是右边开始搜索分割符。
test = "testasdsddfg"
v = test.partition('s')
print(v)                     #输出('te', 's', 'tasdsddfg')
v = test.rpartition('s')
print(v)                     #输出('testasd', 's', 'ddfg')

22 分割为指定个数

test = "testasdsddfg"
v1 = test.split('s',2)   #split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串;
print(v1)                #输出['te', 'ta', 'dsddfg']
v2 = test.rsplit('s',2)
print(v2)                #输出['testa', 'd', 'ddfg']

23 分割，只能根据，true，false：是否保留换行

#splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，
# 如果参数 keepends 为 False（默认），不包含换行符，如果为 True，则保留换行符。
test = "asdfadfasdf\nasdfasdf\nadfasdf"
v1 = test.splitlines(False)   #输出['asdfadfasdf', 'asdfasdf', 'adfasdf']
v2 = test.splitlines(True)    #输出['asdfadfasdf\n', 'asdfasdf\n', 'adfasdf']
print(v1,v2)

24 以xxx开头，以xx结尾

test = "backend 1.1.1.1"
v1 = test.startswith('b')
print(v1)                  #输出True
v2 = test.endswith('b')
print(v2)                  #输出False

25 大小写转换

test = "aLEx"
v = test.swapcase()   #输出AleX
print(v)

26 字母，数字，下划线 ： 标识符 def class

#isidentifier() 方法用于判断字符串是否是有效的 Python 标识符，可用来判断变量名是否合法；
#如果字符串是有效的 Python 标识符返回 True，否则返回 False。
a = "def"
v = a.isidentifier()
print(v)                            #True
print( "if".isidentifier() )        # True
print( "def".isidentifier() )       # True
print( "class".isidentifier() )     # True
print( "_a".isidentifier() )        # True
print( "中国123a".isidentifier() )   # True
print( "123".isidentifier() )       # False
print( "3a".isidentifier() )        # False
print( "".isidentifier() )          # False

27 将指定字符串替换为指定字符串

#replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，
# 如果指定第三个参数max，则替换不超过 max 次。
test = "alexalexalex"
v = test.replace("ex",'bbb')
print(v)                             #输出albbbalbbbalbbb
v = test.replace("ex",'bbb',2)
print(v)                             #输出albbbalbbbalex

###################### 7个基本魔法 ################################
# join # '_'.join("asdfasdf")
# split
# find
# strip
# upper
# lower
# replace
###################### 4个灰魔法 ##################################

1 for循环

# for 变量名 in 字符串:
# 变量名
# break         跳出循环体
# continue    跳出单次循环

test = "郑建文妹子有种冲我来"
index = 0
while index < len(test):
    v = test[index]
    print(v)
    index += 1
print('=======')     
#输出
郑
建
文
妹
子
有
种
冲
我
来
=======

test = "郑建文妹子有种冲我来"
for zjw in test:
    print(zjw)
#输出
郑
建
文
妹
子
有
种
冲
我
来

test = "郑建文妹子有种冲我来"
for item in test:
    print(item)
    break
#输出
郑

test = "郑建文妹子有种冲我来"
for item in test:
    continue
    print(item)        #什么也不输出

2 索引，下标，获取字符串中的某一个字符

test = "郑建文妹子有种冲我来"
v = test[3]
print(v)     #输出妹，索引下标从0开始

3 切片

test = "郑建文妹子有种冲我来"
v = test[0:-1] # 0=<范围<-1，输出郑建文妹子有种冲我
print(v)

4 获取长度

test = "郑建文妹子有种冲我来"
v = len(test)                  #Python3： len获取当前字符串中由几个字符组成
print(v)

# 注意：
# len("asdf")
# for循环
# 索引
# 切片

5 获取连续或不连续的数字

Python2中直接创建在内容中
python3中只有for循环时，才一个一个创建
格式一：range(stop)
格式二：range(start, stop[, step])
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
r1 = range(10)           #输出range(10)，对应0-9
r2 = range(1,10)         #输出range(1,10)，对应1-9
r3 = range(1,10,2)       #输出range(1,10,2)，对应1，3，5，7，9
print(r1,r2,r3)
帮助创建连续的数字,通过设置步长来指定不连续
v = range(0, 100, 5)
for item in v:
print(item)             #输出0,5,10,15,20...90,95

##### 练习题：根据用户输入的值，输出每一个字符以及当前字符所在的索引位置 ##################

test = input(">>>")
for item in test:
    print(item)

# 将文字对应的索引打印出来：
test = input(">>>")
print(test) # test = qwe test[0] test[1]   #输入qwe
l = len(test) # l = 3
print(l)                                   #输出3
r = range(0,l) # 0,3
for item in r:
    print(item,test[item]) # 0 q,1 w,2 e

test = input(">>>")
for item in range(0, len(test)):
    print(item, test[item])

###################### 1个深灰魔法 ################################################
# 字符串一旦创建，不可修改
# 一旦修改或者拼接，都会造成重新生成字符串

name = "zhengjianwen"
age = "18"
info = name + age
print(info)          #输出zhengjianwen18

列表 list
...
元祖 tuple
...
字典 dict
...
布尔值 bool
...

----> 列表,元祖,字典,布尔值 详细操作见下章