python 数据类型

字符串，元组，列表。关于公共方法，都有for循环，索引，切片，步长，长度len()值、

一 int 整型

　　1.bit_length()   二进制表示自身时最少的二进制位数。

　　

a=33
print(a.bit_length())

　　输出：6

　　2 公共方法

　　len()

二 str 字符串类型,格式是 ‘ ’

　　因为str类型是不可变类型，所以对字符串进行操作，需要重新赋值给一个新的变量名。可有变量名的 id 来确认。

　　例如：

　　

s='abCDeF'
print(id(s))
new_s=s.upper()
print(s,id(s))
print(new_s,id(new_s))

　　结果：

　　

2063906226728
abCDeF 2063906226728
ABCDEF 2063907062312

　　s前面指向内存中的同一块地址，因为字符串是不可变类型。

　　1 统一变大写——upper()方法

　　

s='abCDeF'
new_s=s.upper()
print(s)
print(new_s)

　　结果：

　　

abCDeF
ABCDEF

　　2 统一变小写——lower()方法

　　

s='abCDeF'
new_s=s.lower()
print(s)
print(new_s)

　　结果：

　　

abCDeF
abcdef

　　3首字母大写——capitalize()方法。

　　注意：字符串首字母会大写，首字母后面的字母如果原本是大写，也会变为小写。

　　

s='abCDeF'
new_s=s.capitalize()
print(s)
print(new_s)

 　　结果：

　　

abCDeF
Abcdef

　　4 切割——split()方法

　　这个方法非常强大，用的也特别多。字符串进行切割后返回的是一个列表。

　　split有两个参数。

　　

　　split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
    """
    S.split(sep=None, maxsplit=-1) -> list of strings

    Return a list of the words in S, using sep as the
    delimiter string.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified or is None, any
    whitespace string is a separator and empty strings are
    removed from the result.
　　

　　"""　　
　　

s='学挖掘机哪家强，中国山东找蓝翔！好客山东欢迎您！'
new_s=s.split('山东')
print(new_s)
new_s=s.split('山东',1)
print(new_s)

　　结果：

['学挖掘机哪家强，中国', '找蓝翔！好客', '欢迎您！']
['学挖掘机哪家强，中国', '找蓝翔！好客山东欢迎您！']

　　可以看出，split方法后返回的是一个列表，里面的元素是separator前后的字符串。很重要的一点是切割后，sepatator会被移除掉。  数字‘1’表示进行切割的次数。默认是有separator，进行全部切割。

　　5 去除首位空白字符（white space），包含空格 space，制表符 \t，换行符 \n，——strip()方法，lstrip(), rstrip()。

　　在for line in f，line=line.strip()，作用就是去除最后面的一个\n。因为for line 读取的就是每一行，遇到 \n 才换行，但是line 会将 \n读取到。

　　例如：

s='\tabc'
print(s)
print(s.strip())

　　输出：

	abc
abc

　　

 

　　这是一个非常重要，用处非常多的一个方法。

name=input('请输入名称：')
if name=='Alex':
    print('da sha bi')

　　如果用户手贱输入'Alex     ’，前面后面都有空格，那如上面所示，条件判断就是False。如果解决，就需要strip()方法。　

name=input('请输入名称：').strip()
if name=='Alex':
    print('da sha bi') 

　　很明显，lstrip是对左侧字符串的去除空格，rstrip是对右侧字符串的去除空格，strip是对字符串左右两侧的空格进行去除。

　　

　　strip默认是去除空格，还可以做到更多。　

s='abcedf'
new_s=s.strip('abf')
print(s)
print(new_s)

　　效果上可以达到删除某些字符串的功能。结果是：

abcedf
ced

　　6 替换——replace()

　　由于字符串是不可变类型，所以不能通过索引定位来更改字符，需要借用replce方法来改动字符。

　　replace需要两个必要参数，需要改的字符，改动后的字符。数字并不是必要的，如果没有，默认是全部替换。如果存在数字，更改设定的次数。

s='abcedfab'
new_s=s.replace('ab','AB',1)           
print(s)
print(new_s)

　　结果：

abcedfab
ABcedfab

　　

　　

a='abcabcabc'
print(a.replace('a','A'))

　　输出：

AbcAbcAbc                #注意：默认是全部替换！！

　

　　7 公共方法

　　len（）字符串的长度　

s='abcedfab'
print(len(s))

 　[ ] 索引,只能定位，不能修改。

s='abcedfab'
print(s[3])

　　结果：

e

　　[x:x ] 切片，只能定位，不能更改。

s='abcedfab'
print(s[1:4])

　　结果：

bce

 　　关于切片的说明：

　　类标的切片相当于是对原列表的一个复制，原列表并没变化。所有如果想拿到列表的部分数据，但又期望原列表不变，这个时候切片就是最佳的选择了。与之相对应的是，列表的方法是会直接作用到列表上的，因为列表是可变类型。

　　例如：

l=[1,2,3,4,5,6,7,8,9]
ll=l[::-1]
print(l)
print(ll)

　　输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

　　

　　列表的reverse方法

l=[1,2,3,4,5,6,7,8,9]
ll=l.reverse()
print(l)
print(ll)

　　输出：

[9, 8, 7, 6, 5, 4, 3, 2, 1]
None

　　这两个实验说明了上述的结论。关于None的说明，是因为reverse方法本质上是一个函数，并没有设定返回值，所以默认为None。

　　for循环，字符串是可迭代对象。

　　

s='abcedfab'
for item in s:
    print(item)

　　

三 元组 tuple

　　PS元祖的核心是逗号，而不是小括号

　　举例：

a=1,2,3
print(a)
print(type(a))

　　输出：

(1, 2, 3)
<class 'tuple'>

　　

　　　举例：

print(3*(40+3))      
                     
print(3*(40+3,))     
                     

　　输出：

129
(43, 43, 43)

　　

　　元组和字符串一样是不可变类型。

　　元组具有的公共方法有：

　　len()

　　索引，切片，不能更改元组内的数据。

　　for循环。

四 布尔类型 bool　　

　　布尔值只有两种。True False

　　False：0，‘’（零，空）

　　True：非零，非空

五 列表类型 list，格式是 [ ]

　　列表是可变类型，所以可对列表本身进行操作。与元组，字符串不同的是，列表有一些独有的方法。

　　1 追加一个——append（），将元素追加在列表的末尾。

　　　追加多个——extend（），extend方法的参数必须是可迭代对象，比如列表。

l=[1,2,3,4]
l.extend([5,6,7])
print(l)

　　输出：

[1, 2, 3, 4, 5, 6, 7]

　　

　　2 插入——insert（）。　

l=['a','b','c','d','e']
l.insert(2,2)
print(l)

　　结果：

['a', 'b', 2, 'c', 'd', 'e']

　　insert有两个参数，第一个是列表的索引index，第二个是要插入的元素。规定insert object before index。

　　3列表的修改，可以直接通过索引或者切片来实现。

　　索引改动：

l=['Alex','egon','yuanhao','小姨妈','葫芦','银角大王']
l[0]='鸡汤大王'
print(l)

　　切片改动：

l=['Alex','egon','yuanhao','小姨妈','葫芦','银角大王']
l[0:2]=['鸡汤使者','沙河舞王','日天']
print(l)

　　结果：

['鸡汤使者', '沙河舞王', '日天', 'yuanhao', '小姨妈', '葫芦', '银角大王']

　　

　　4 删除

　　 　　pop()方法                  注意：pop()方法时唯一一个既能修改列表又返回元素值（除了None）的列表方法

　　　　remove()方法

　　　　del语句

　　5 for循环，列表是可迭代对象

　　6 补充：列表推导式

　　很精髓的一句话是：列表推导式是利用其他列表创建新列表的一种方法。它的工作方式类似于for循环。

　　　　1 列表推导式的先天条件：起码有个列表，让我遍历循环吧

　　　　2 列表推导式的结果：这不是废物吗，生成一个新的列表，对，结果是一个列表。

　　例如：

l = [ 'https://www.baidu.com?page={}'.format(i) for i in range(10)]
print(l)

　　输出：

['https://www.baidu.com?page=0', 'https://www.baidu.com?page=1', 'https://www.baidu.com?page=2', 'https://www.baidu.com?page=3', 'https://www.baidu.com?page=4', 'https://www.baidu.com?page=5', 'https://www.baidu.com?page=6', 'https://www.baidu.com?page=7', 'https://www.baidu.com?page=8', 'https://www.baidu.com?page=9']

 

六 字典 dict，格式是  {‘key1’：‘value1’,'key2':'value2'}

　　1 get方法

　　

d={'五期':'娜娜老师','七期':'星儿老师'}

print(d.get('六期'))
print(d.get('七期　　'))

　　结果：

None
星儿老师

　　get方法与直接d['七期']一样的效果，但是当字典key值不存在是，字典引用不存在的key值，会报错。而字典get（不存在的key值），不会报错，返回None。

　　基于以上这点，get方法在字典中的出镜率还是蛮高的。

　　实例1：

dic={}
l=[1,2,3,4,5]
for i in l:
    if i >3:
        if dic.get('k1'):
            dic['k1'].append(i)
        else:
            dic['k1']=[i]
    else:
        if dic.get('k2'):
            dic['k2'].append(i)
        else:
            dic['k2']=[i]
print(dic)

　　输出：

{'k2': [1, 2, 3], 'k1': [4, 5]}

　　

　　实例2

d={}
name=input('===>')
pwd=input('==>')
if d.get(name)==pwd:                 #如果用户信息是以用户名为和某种信息作为键值对，get方法就可以用的很灵活。逼格很高！
    print('登录成功！')

　　

　　

 

　　keys（）方法，values（）方法，item（）方法，本来是dict_**格式，可以通过list变为列表格式，其中item变为列表格式后，元素是key-value配对的元组。

d={'五期':'娜娜老师','七期':'星儿老师'}

print(d.values(),type(d.values()),list(d.values()))
print(d.keys(),type(d.keys()),list(d.keys()))
print(d.items(),type(d.items()),list(d.items()))

　　输出：

dict_values(['娜娜老师', '星儿老师']) <class 'dict_values'> ['娜娜老师', '星儿老师']
dict_keys(['五期', '七期']) <class 'dict_keys'> ['五期', '七期']
dict_items([('五期', '娜娜老师'), ('七期', '星儿老师')]) <class 'dict_items'> [('五期', '娜娜老师'), ('七期', '星儿老师')]

　　

　　2  fromkeys 方法

d=dict.fromkeys(('x','y','z'),[])         fromkeys方法，第一个参数为可迭代对象，可迭代对象里的每个元素作为key值，第二个参数作为value值。所有的key值都指向同一个value，即指向第二个参数。
print(d)
for i in d.values():
    print(id(i))

　　输出：

{'x': [], 'y': [], 'z': []}
2015503437896
2015503437896
2015503437896

　　这个方法用于批量产生键值对，但用处很受限制。如果第二个参数是可变类型，基本上没用。第二个参数是不可变类型，才有存在的价值。

　　例如：　

d=dict.fromkeys(['alex','egon','yuanhao'],'male')
print(d)

　　输出：

{'alex': 'male', 'egon': 'male', 'yuanhao': 'male'}

　　

　　3 列表与字典转换

l = [['a',1],['b',2],['c',3]]
d = dict(l)

　　输出

{'a': 1, 'b': 2, 'c': 3}

 

　　七集合set

　　集合的元素有一个要求，必须是不可变类型，如果是列表，字典，集合会报错。　

　　集合的存在的价值：

　　　　1 去重

　　　　2 关系元素 & | ^ -

s={1,2,[3,4]}

　　输出：　

TypeError: unhashable type: 'list'

　　

　　八 类型之间的相互转换

　　布尔值与其他类型的转换：

　　　　False： 0，‘’,[ ],( ),{ }　　

　　　　True:　除False，都为True

　　字符串str 与整形int的相互转换：

　　　　整型可以无压力转换为str，str全部是数字或者第一个是‘-’，其余全部是数字，可以转变为int型。

　　列表转变为字符串

　　　　方法一，直接转换，但是然而并没有什么卵用，可以是可以，但是没有使用价值。

　　　　在dos界面运行如下：　　

>>> l
['好客', '山东', '欢迎你']
>>> s=str(l)
>>> s
"['好客', '山东', '欢迎你']"

　　　　方法二，用到字符串的join方法，很666.　　　

>>> l
['好客', '山东', '欢迎你']
>>> ss=''.join(l)
>>> ss
'好客山东欢迎你'

　　元组转变为字符串与列表转变为字符串一样的方法，一样的效果。

>>> t=('a','b','c')
>>> s=str(t)
>>> s
"('a', 'b', 'c')"

　　

>>> t
('a', 'b', 'c')
>>> ts=''.join(t)
>>> ts
'abc'

　　

　　字符串转变为列表和元组。可以理解为基于for循环，或者基于字符串的单个索引，变成列表或者元组的一个元素。

>>> s='abcdef'
>>> l=list(s)
>>> l
['a', 'b', 'c', 'd', 'e', 'f']

　　

>>> s='abcdef'
>>> t=tuple(s)
>>> t
('a', 'b', 'c', 'd', 'e', 'f')

 

　　字典转变为列表和元组，更可以看出是基于for循环，遍历。

>>> d={'k1':1,'k2':2}
>>> l=list(d)
>>> l
['k1', 'k2']

　　

>>> d={'k1':'a','k2':2,'k3':'rrr'}
>>> dt=tuple(d)
>>> dt
('k1', 'k2', 'k3')

　　

　　　　

 

　　

转载于:https://www.cnblogs.com/654321cc/p/7391482.html