python基础二

一 、数据类型

　　数字、字符串、布尔、列表、元祖、字典、集合

二、数字int

　　#bit_length()  当十进制用二进制表示时，最少使用的位数

v = 8
d = v.bit_length()
print(d)    #4

三、布尔值bool:  True,False

　　真  1  True

　　假  0  False

四、字符串str

　　4.1：字符串的索引 

　　　　索引即下标，初始索引为0（从字符串组成的元素的第一个开始），以此类推

s = 'helloworld'
print(s[0])  #h   0表示第一个
print(s[4])  #o
print(s[-1]) #d   -1表示从右往左取值，-1,-2...

　　4.2：字符串的切片

　　　　切片就是通过索引 （索引：索引：步长）截取字符串中的一段，形成新的字符串。原则就是顾头不顾尾。

　　

#第一个参数是要截取的初始位置（包含此索引）
#第二个参数是要截取的终点位置（不包含此索引）
# 第三个参数是步长

s = 'abcdefghij'
print(s[0:3])      #abc
print(s[0:])        #abcdefghij
print(s[:])          #abcdefghij  跟上步一样
print(s[0:-1])     #abcdefghi  -1就是最后一个，但不包含那个
print(s[0:7:3])   #adg    加了3的步长
print(s[5:0:-2])  #fdb    反向步长
print(s[::-2])     #jhfdb

　　

　　4.3：字符串的常用方法　　　　

#capitalize  首字母大写
s = 'today is Monday'
print(s.capitalize()) #Today is monday
#swapcase  大小写翻转
print(s.swapcase())  #TODAY IS mONDAY
#title   每个单词的首字母大写（空格，乘号等特殊符号区分，数字也算特殊字符）

 print(s.title()) #Today Is Monday #upper 全转大写 print(s.upper()) #TODAY IS MONDAY #lower 全转小写 print(s.lower()) #today is monday

#center居中（第一个参数是总长度，第二个参数是空白处填充内容）
s = 'helloworld'
print(s.center(21,'#')) #  ######helloworld#####

#count统计字符串中的指定元素出现的个数
print(s.count('l',0,4))  #2   可切片

 

#expandtabs()
s1 = 'hqw	hehe'
print(s1.expandtabs())  #hqw     hehe
s2 = 'goodMorning	hello'
print(s2.expandtabs())  #goodMorning     hello
#	前面的补全
#默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8；
# 如果tab前面的字符长度超过8个但不足16个，则补全16个，以此类推每次补全8个

#startswith  判断是否以...开头
#endswith  判断是否以...结尾
s = 'helloworld'
print(s.startswith('he')) # True  后面参数不写，则默认整个字符串中查询
print(s.startswith('el',1,4))  # True  表示从第一个索引（含）到第五个索引（不含）
print(s.startswith('ho',0,6))  #False
print(s.endswith('ld',3,))  #True  顾头不顾尾

#find 寻找字符串中的元素是否存在
s = 'dandanzhu'
print(s.find('dan',1,7))  # 3  找到返回索引
print(s.find('dan',1,4))  # -1  找不到返回-1

# index 寻找字符串中的元素是否存在
print(s.index('dan',1,7))  # 3  找到返回索引
print(s.index('dan',1,4))  # -1  找不到会报错

# split 以什么分割，最终形成一个列表不含有这个分割的元素
#一分为二，尤其注意的是当左边没有字符的时候，它会拆成一个''
s = 'title,tiTle,Title'
print(s.split('t'))  # ['', 'i', 'le,', 'iTle,Ti', 'le']
s1 = 'hello world'
print(s1.rsplit('o',1))   # ['hello w', 'rld']
print(s1.rsplit('o',2))   # ['hell', ' w', 'rld']
print(s1.rsplit('o',0))   # ['hello world']
print(s1.rsplit('o'))     # ['hell', ' w', 'rld']
# rsplit表示从右侧开始以指定字符窜来分割，第二个参数不写，则默认整个字符串中进行截取
# split没有lsplit

#strip
s = '*hjmhjm**'
print(s.strip('*')) # hjmhjm  去除头尾的指定字符，如*，空格等
print(s.lstrip('*')) #hjmhjm**  去除头部的指定字符*
print(s.rstrip('*')) #*hjmhjm  去除尾部的指定字符*

#format的三种语法 格式化输出
s = '我叫{}，性别{}，爱好{}，再说一次我叫{}'.format('hjm','男','girl','hjm')
#我叫hjm，性别男，爱好girl，再说一次我叫hjm
print(s)
s2 = '我叫{1}，性别{0}，爱好{2}，再说一次我叫{1}'.format('男','hjm','girl')
print(s2)
s3 = '我叫{name}，性别{sex}，爱好{hobby}，再说一次我叫{name}'.format(sex='男',name='hjm',hobby='girl')
print(s3)

#replace  替换 （旧字符串，新字符串，替换次数）
s = 'cat say: I love eat fish!cat'
print(s.replace('cat','SB')) #SB say: I love eat fish!SB
print(s.replace('cat','SB',1)) #SB say: I love eat fish!cat

#is系列
s = 'admin123'
print(s.isalnum())  # True  字符串由字母或数字组成
print(s.isalpha())  # False  字符串只由字母组成
print(s.isdigit())  # False  字符串只由数字组成

五、for循环

s = 'fhdskl'
for i in s:
    print(i)

# f  h  d  s  k  l

 六、列表list

　　#增

　　#方法1  append

li = ['张三','李四','王二麻子','lucy','jim']
li.append('文文') # ['张三', '李四', '王二麻子', 'lucy', 'jim', '文文']
li.append(1) #['张三', '李四', '王二麻子', 'lucy', 'jim', '文文', 1]
print(li)

　　

li = ['张三','李四','王二麻子','lucy','jim']
while 1:
    username = input("输入员工名字/按q退出：")
    if username.strip().upper() != 'Q':
        li.append(username)
    else:
        break
print(li)

　　#方法2  insert

li = ['张三','李四','王二麻子','lucy','jim']
li.insert(4,'haha') #['张三', '李四', '王二麻子', 'lucy', 'haha', 'jim']
print(li)

　　#方法3   extend   (int不可迭代)

li = ['张三','李四','王二麻子','lucy','jim']
li.extend('二哥')  #['张三', '李四', '王二麻子', 'lucy', 'jim', '二', '哥']
li.extend([1,2,3])  #['张三', '李四', '王二麻子', 'lucy', 'jim', 1, 2, 3]
li.extend(123)  #  报错'int' object is not iterable
print(li)

　　#删

　　#方法1  pop  （参数如果什么都不写的话，则默认删除的最后一个）有返回值，返回你删除的元素

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
li.pop(1) #['张三', '王二麻子', 'lucy', 'jim']
li.pop()   #['张三', '王二麻子', 'lucy']
print(li)

　　#方法2  remove  

#没有返回值，按元素删除

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
li.remove('lucy')  # ['张三', '李四', '王二麻子', 'jim'] 没有返回值，按元素删除 
print(li)

　　#方法3  clear 清空列表

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
li.clear()
print(li)  #[]

　　#方法4   del  删除列表    删除列表后再也找不到此列表，打印会报错

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
del li  
print(li)

 　　#方法5   del li[2:]   切片删除    删除指定的元素

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
del li[2:]
print(li)  #['张三', '李四']

　　#改    按索引、按切片

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
li[0] = '男兽'  #['男兽', '李四', '王二麻子', 'lucy', 'jim']
li[1] = [1,2,3]   #['张三', [1, 2, 3], '王二麻子', 'lucy', 'jim']
li[0:2] = '云姐pl'  #['云', '姐', 'p', 'l', '王二麻子', 'lucy', 'jim']
li[0:2] = ['haha']  #['haha', '王二麻子', 'lucy', 'jim']
print(li)

　　#查

li = ['taibai','alex','wusir','egon','女神']
for i in li:
    print(i)

print(li[0:2])

 在循环一个列表时，最好不要删除列表中的元素，这样会使索引发生改变，从而报错或出现其它问题

 #fromkeys

dic = dict.fromkeys([1,2,3],'春哥')
print(dic)   # {1: '春哥', 2: '春哥', 3: '春哥'}

dic = dict.fromkeys([1,2,3],[])
dic[1].append('a')
print(dic)   # {1: ['a'], 2: ['a'], 3: ['a']}

七、元组    （只读列表，可循环查询，可切片。 儿子不能改，孙子可能可以改）

tu = (1,2,3,'hjm',[2,3,4,'lucy'],'jim')
print(tu[3])  #hjm
print(tu[0:4])  #(1, 2, 3, 'hjm')

for i in tu:
    print(i)

tu[4][3] = tu[4][3].upper()
print(tu)   #(1, 2, 3, 'hjm', [2, 3, 4, 'LUCY'], 'jim')

tu[4].append('SB')
print(tu)   # (1, 2, 3, 'hjm', [2, 3, 4, 'LUCY', 'SB'], 'jim')

八、公共方法

　　len()  长度

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
l = len(li)
print(l)  #5

　　index()  查找索引，找到返回索引，没找到则会报错  （列表查找没有find()方法）

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
print(li.index('lucy'))  #3

　　count()  统计数

li = ['张三', '李四', '王二麻子', 'lucy', 'jim']
print(li.count('jim')) # 1
print(li.count('ji')) # 0  查找整个元素，不能查一半

　　#排序  sort()   reverse()

li = [3,5,9,2,4,7]
li.sort()  #[2, 3, 4, 5, 7, 9]  默认正向排序
li.sort(reverse=True)  #[9, 7, 5, 4, 3, 2]  倒序排序
li.reverse()  #[7, 4, 2, 9, 5, 3] 反转
print(li)

　　

　　#列表的嵌套

li = ['hjm','李四','王二麻子',['lucy','jim',89],23]
print(li[2][3])  #子
name = li[0].capitalize()
li[0] = name
print(li) #['Hjm', '李四', '王二麻子', ['lucy', 'jim', 89], 23]

　　#join  必须是可迭代对象

s = 'hjm'
s1 = '_'.join(s)  
print(s1)  #h_j_m

li = ['hjm','aa','ss']
s = '+'.join(li)
print(s)  #hjm+aa+ss

　　注：列表使用join方法时，里面每个元素都得是字符串，不能是数字或再嵌套列表什么的，不然报错

#str  ---> list   split
#list ---> str    join

　　#range  (指定范围，生成指定数字)  顾头不顾尾

for i in range(0,5):
    print(i)  # 0 1 2 3 4
for i in range(5):
    print(i)  # 0 1 2 3 4
#只写一个参数的话，默认从0开始

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

 　　#enumerate:枚举，对于一个可迭代的/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值

li = ['a','lucy','jim','lisi']
for i in li:     #起始的默认位置是0，可更改
    print(li.index(i),i)
'''
    0 a
    1 lucy
    2 jim
    3 lisi
'''

for index,v in enumerate(li,100):
    print(index,v)
'''
    100 a
    101 lucy
    102 jim
    103 lisi
'''

练习1：将列表 li = [1,2,3,5,'hjm',[2,3,4,5,'lucy'],'afds']中所有的元素都遍历出来

li = [1,2,3,5,'hjm',[2,3,4,5,'lucy'],'afds']
#方法1
for i in li:
    if type(i) == list:
        for j in i:
            print(j)
    else:
        print(i)

#方法2
for i in range(len(li)):
    if type(li[i]) == list:
        for j in li[i]:
            print(j)
    else:
        print(li[i])

 练习2：将列表lis = [11,22,33,44,55]中索引是奇数的元素删除

#方法1
del lis[1::2]
print(lis)

#方法2：
lis = lis[::2]
print(lis)

#方法3：
l1 = []
for i in lis:
    if lis.index(i) % 2 == 0:
        l1.append(i)
lis =  l1
print(lis)

#方法4： 倒着删除，不会影响前面的索引
for i in range(len(lis)-1,-1,-1):
    if i % 2 != 0:
        del lis[i]
print(lis)