Python基本数据类型

运算符                                                                      

• 算数运算
• 比较运算
• 赋值运算
• 逻辑运算
• 成员运算

 

一、算数运算

二、比较运算

三、赋值运算

四、逻辑运算

五、成员运算

 

基本数据类型                                                              

一、数字

int（整形）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

二、布尔值

真或假 True False

1或0

三、字符串

“hello world”

 1、常用功能：

• 移除空白
• 分割
• 长度
• 索引
• 切片

2、循环

white循环 

s = "alex"
start = 0
while start < len(s):
    temp = s[start]
    print(temp)
    start += 1
a
l
e
x

for循环

s = "alex"
for item in s:
    print(item)
a
l
e
x

for循环中，break和continue同样适用

s = "alex"
for i in s:
    if i == "e":
        continue
    print(i)
a
l
x

s = "alex"
for i in s:
    if i == "e":
        break
    print(i)
a
l

3、内部功能：

##索引

实例：

s = "wang"
print(s[0])
w
print(s[1])
a
print(s[2])
n
print(s[3])
g

def len(*args, **kwargs): #获取长度

实例：

ret = len(s)
print(ret)
4

##切片

实例：

#取字符串中前两个字符
# 0=<0,1<2
s = "alex"
print(s[0:2])
al

 

def capitalize(self): #首字母变成大写
实例：

a1 = "haha"
ret = a1.capitalize()
print(ret)
Haha

def casefold(self): #其效果和 lower() 方法非常相似，都可以转换字符串中所有大写字符为小写。

实例：

a1 = "HaHa"
ret = a1.casefold()
print(ret)
haha

def center(self, width, fillchar=None): #内容居中，width：总长度，fillchar：空白处填充内容，默认无

实例：

a1 = "hhh"
ret = a1.center(20,'_')
print(ret)
________hhh_________

def count(self, sub, start=None, end=None): #子序列的个数，也就是某个元素出现的次数，start从哪开始，从哪里截止。

实例：

##a在a1字符串中出现的次数
a1 = "alex is alph"
ret = a1.count('a')
print(ret)
2
##a在a1字符串中，从0至5这个区间中出现的次数
a1 = "alex is alph"
ret = a1.count('a',0,5)
print(ret)
1

def encode(self, encoding='utf-8', errors='strict'): # 编码,针对Unicode

def decode(self, encoding='utf-8', errors='strict'): #解码

endswith(self, suffix, start=None, end=None): #是否以XX结尾

实例：

##是否以o结尾的
temp = "hello"
print(temp.endswith('o'))
True
#字符串里大于0小于2的字符中，是否有以e结尾的
print(temp.endswith('e',0,2))
True

expandtabs(self, tabsize=8): #将tab键转换成空格，默认一个tab转换成8个空格

实例：

conten = "hello\t999" ##\t 制表符代表tab键
print(conten)
hello    999
#将tab键换成空格,一个tab键是8个空格
print(conten.expandtabs())
hello   999
#指定转换成20个空格
print(conten.expandtabs(20))
hello               999

find(self, sub, start=None, end=None): #寻找子序列的位置，找到了就返回所在的位置，有重复的，只显示找到的第一个的位置，找不到就显示-1

实例：

s = "wxx hello"
print(s.find("x"))
1
print(s.find("b"))
-1

format(self, *args, **kwargs): #字符串的格式化，动态参数

实例：

s = "hello {0},age {1}"
print(s)
hello {0},age {1}
#{0} 占位符，必须是从0开始
#format的作用是将传入的参数替换成占位符
new1 = s.format('wxq','27')
print(new1)
hello wxq,age 27

def index(self, sub, start=None, end=None): #子序列的位置，功能同find()找到就返回其位置，如果没有找到，报错

def isalnum(self): # 是否是字母和数字

实例：

a = "wxq12"
b = a.isalnum()
#验证字符串是否只是字母和数字
print(b)
True

def isalpha(self): # 是否是字母

实例：

a = "wxq12"
b = a.isalpha()
#验证字符串是否只是字母
print(b)
False

def isdecimal(self): #检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

实例：

str = u"this2009"
print(str.isdecimal())
False
str = u"2323241245421"
print(str.isdecimal())
True

def isdigit(self): # 检查字符串是否只包含数字

实例：

a = "12122312"
b = a.isdigit()
#验证字符串是否只是数字
print(b)
True

def isidentifier(self): #判断字符串是否是合法的标识符，字符串仅包含中文字符合法，实际上这里判断的是变量名是否合法。

实例：

print('3'.isidentifier())
False
print('_3'.isidentifier())
True
print('3sdf'.isidentifier())
False
print('呵呵'.isidentifier())
True

def islower(self): # 验证字符串是否小写

实例：

a = "sdjflsdjf"
b = a.islower()
#验证字符串是否小写
print(b)
True

def isspace(self): #验证是否空格

实例：

a = "   "
a1 = "s s"
b = a.isspace()
b1 = a1.isspace()
#验证字符串是否是空格
print(b)
True
print(b1)
False

def istitle(self): #验证字符串首字母是否是标题（首字母大写）

实例：

a = "Sdjf Flsdjf"
b = a.istitle()
#验证字符串首字母是否是标题（首字母大写）
print(b)
True

def isupper(self): #验证字符串是否全部是大写

实例：

a = "SDFS"
b = a.isupper()
#验证字符串是否全部是大写
print(b)
True

def join(self, iterable): #连接，自定义某个字符作为间隔参数，将每个元素连接起来

实例：

l1 = ["al","wa"] #列表
l2 = ("alex","wang") #元组
s1 = "3&！".join(l1)
s2 = "^___".join(l2)
print(s1)
al3&！wa
print(s2)
alex^___wang

def lower(self): #变成小写

实例：

#变成小写
aa = "The NAME"
print(aa.lower())
the name

def ljust(self, width, fillchar=None): #内容左对齐，指定字符串的长度，并且自定义后面的填充内容

实例：

a = "sfs ws sdf"
print(a.ljust(20,'&'))
sfs ws sdf&&&&&&&&&&

def lstrip(self, chars=None): # 移除左侧的空格

def rstrip(self, chars=None): # 移除右侧的空格

def strip(self, chars=None): # 移除两侧的空格

实例：

s = "   al ex    "
#移除左边的空白（空格）
news = s.lstrip()
print(news)
al ex
#移除右边的空白（空格）
news = s.rstrip()
print(news)
   al ex
#移除两边的空白（空格），如果中间有空格则无法去除
news = s.strip()
print(news)
al ex

def partition(self, sep): #分割，前，中，后三部分，从左向右查找，将设定的字符串分割成元组

实例：

s = "alex SB alst haha"
ret = s.partition('SB')
#将设定的字符串分割成元组
#('alex ', 'SB', ' alst')
print(ret)
('alex ', 'SB', ' alst haha')

def replace(self, old, new, count=None): #替换

实例：

s = "alex SB alst SDFal"
ret = s.replace("al","BB")
#从左往右匹配al，替换成BB，第三个参数是指要替换前几次出现的次数
ret1 = s.replace("al","BB",2)
print(ret)
BBex SB BBst SDFBB
print(ret1)
BBex SB BBst SDFal

def rfind(self, sub, start=None, end=None): #从右向左查找字符串中的字符

实例：

#rfind的功能是从右向左查找字符串中的字符
s = "wxq hq"
#找到了就返回出所在的位置，如果有重复的，只显示找到的第一个的位置，找不到就显示-1
print(s.rfind("q"))
5
print(s.rfind("b"))
-1

def rindex(self, sub, start=None, end=None): #从右向左查找子序列的位置，功能同rfind()找到就返回其位置，如果没有找到，报错

def rjust(self, width, fillchar=None): #内容右对齐，指定字符串的长度，并且自定义左侧的填充内容

实例：

# #内容右对齐，指定字符串的长度，并且自定义左侧的填充内容
a = "sfs ws sdf"
print(a.rjust(20,'&'))
&&&&&&&&&&sfs ws sdf

def rpartition(self, sep): #分割，前，中，后三部分，从左向右查找，将设定的字符串分割成元组

实例：

#从右向左查找，将设定的字符串分割成元组
s = "alex SB alet haha"
ret = s.rpartition('e')
print(ret)
('alex SB al', 'e', 't haha')

def split(self, sep=None, maxsplit=-1): #分割，从左向右匹配

实例：

##分割
s = "alexalex"
#匹配字符串e进行分割，同时不再显示e
ret = s.split("e")
print(ret)
['al', 'xal', 'x']
#将匹配到第一次出现的e进行分割，同时不再显示e
ret1 = s.split("e",1)
print(ret1)
['al', 'xalex']

def rsplit(self, sep=None, maxsplit=-1): #分割，从右向左匹配

实例：

s = "alexalex"
#从右向左匹配字符串e进行分割，同时不再显示e
ret = s.rsplit("e")
print(ret)
['al', 'xal', 'x']
#将匹配到第一次出现的e进行分割，同时不再显示e
ret1 = s.rsplit("e",1)
print(ret1)
['alexal', 'x']

def splitlines(self, keepends=None): #按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

实例：

str1 = 'ab c\n\nde fg\rkl\r\n'
print(str1.splitlines())
['ab c', '', 'de fg', 'kl']
str2 = 'ab c\n\nde fg\rkl\r\n'
print(str2.splitlines(True))
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

def startswith(self, prefix, start=None, end=None): #是否以XX开始

实例：

##是否以XX开始的
temp = "hello"
print(temp.startswith('h'))
True
#字符串里大于0小于2的字符中，是否有以e结尾的
print(temp.startswith('e',0,2))
False

def swapcase(self): #大小写转换，大写变小写，小写变大写

实例：

s = "aLeC"
print(s.swapcase())
AlEc

def title(self): #变成标题，将开头字母变成大写

实例：

s = "the school"
ret = s.title()
print(ret)
The School

 

def translate(self, table): #
'''
转换，需要先做一个对应表，最后一个表示删除字符集合

intab = "aeiou"

outtab = "12345" trantab = maketrans(intab, outtab) str = "this is string example....wow!!!" print str.translate(trantab, 'xm')
'''

def upper(self): #变成大写

实例：

a  = "hello world"
print(a.upper())
HELLO WORLD

def zfill(self, width): # 方法返回指定长度的字符串，原字符串右对齐，前面填充0,不常用，可忽略

 

四、列表

1、创建:

name_list = ["zhao","qian","sun","li"]
或者
name_list = list(["zhao","qian","sun","li",])

2、基本操作：

• 索引
• 切片
• 追加
• 删除
• 长度
• 循环
• 包含

索引

实例：

name_list = ["zhao","qian","sun","li"]
print(name_list[1])
qian

切片 

实例：

name_list = ["zhao","qian","sun","li"]
print(name_list[0:2])
['zhao', 'qian']

长度

实例：

name_list = ["zhao","qian","sun","li"]
print(len(name_list))
4
print(name_list[2:len(name_list)])
['sun', 'li']

删除

实例：

name_list = ["zhao","qian","sun","li"]
print(name_list)
['zhao', 'qian', 'sun', 'li']
del name_list[1]
print(name_list)
['zhao', 'sun', 'li']
##或者指定一个段
del name_list[1:3]
print(name_list)
['zhao']

循环

实例：

name_list = ["zhao","qian","sun","li"]
for i in name_list:
    print(i)
zhao
qian
sun
li

3、列表内部功能

def append(self, p_object): # 向后追加

 实例：

name_list = ["zhao","qian","sun","li"]
name_list.append('haha')
print(name_list)
['zhao', 'qian', 'sun', 'li', 'haha']

def clear(self): #清除列表

实例：

name_list = ["zhao","qian","sun","li"]
print(name_list)
['zhao', 'qian', 'sun', 'li']
name_list.clear()
print(name_list)
[]

def copy(self): #复制列表

实例：

name_list = ["zhao","qian","sun","li"]
print(name_list)
['zhao', 'qian', 'sun', 'li']
name_list2 = name_list.copy()
print(name_list2)
['zhao', 'qian', 'sun', 'li']

 

def count(self, value): #统计元素出现的个数

实例：

name_list = ["zhao","qian","sun","li"]
print(name_list.count('li'))
1

def extend(self, iterable): #扩展，将一组数据批量追加

实例：

name_list = ["zhao","qian","sun","li"]
temp = [11,22,33,331]
name_list.extend(temp)
print(name_list)
['zhao', 'qian', 'sun', 'li', 11, 22, 33, 331]

def index(self, value, start=None, stop=None): #索引，获取指定元素的索引位置

实例：

name_list = ["zhao","qian","sun","li"]
print(name_list.index("li"))
3

def insert(self, index, p_object): #插入，在索引指定位置，插入元素

实例：

name_list = ["zhao","qian","sun","li"]
name_list.insert(1,"zhou")
print(name_list)
['zhao', 'zhou', 'qian', 'sun', 'li']

def pop(self, index=None): #移除某个元素

实例：

name_list = ["zhao","qian","sun","li"]
print(name_list)
['zhao', 'qian', 'sun', 'li']
name_list.pop()
print(name_list)
['zhao', 'qian', 'sun']

##pop还可以在原列表中移除掉的最后一个值，并将其赋值给变量ret
name_list = ["zhao","qian","sun","li"]
ret = name_list.pop()
print(ret)
li

def remove(self, value): #移除，只能移除从左边往右找到的第一个参数

实例：

name_list = ["zhao","qian","qian","sun","li"]
name_list.remove('qian')
print(name_list)
['zhao', 'qian', 'sun', 'li']

def reverse(self): #翻转列表中的元素的顺序

实例：

name_list = ["zhao","qian","sun","li"]
name_list.reverse()
print(name_list)
['li', 'sun', 'qian', 'zhao']

def sort(self, key=None, reverse=False): #排序

实例：

name_list = ["zhao","qian","sun","li"]
name_list.sort()
print(name_list)
['li', 'qian', 'sun', 'zhao']

五、元组

特征：元组的元素不允许修改 ，不能进行增删改。

1、创建

name_tuple = ('alex','eric','alex','hhh')
或者

name_tuple = tuple(('alex','eric','alex','hhh'))

2、基本操作

• 索引
• 切片
• 循环
• 长度
• 包含

 

索引

实例：

name_tuple = ('alex','eric','alex','hhh')
print(name_tuple[1])
eric

长度(len)

实例：

name_tuple = ('alex','eric','alex','hhh')
print(len(name_tuple))
4
print(name_tuple[len(name_tuple) - 1])
hhh

切片

实例：

name_tuple = ('alex','eric','alex','hhh')
print(name_tuple[0:1])
('alex',)

 for循环

实例：

name_tuple = ('alex','eric','alex','hhh')
for i in name_tuple:
    print(i)
alex
eric
alex
hhh

del 删除整个元组

实例：

del 不可以删除元组的元素，但是可以删除整个元组，删除后print会报错没有定义这个元组
name_tuple = ('alex','eric','alex','hhh')
del name_tuple
print(name_tuple)
NameError: name 'name_tuple' is not defined  

 3、元组内部功能

def count(self, value): # 计算元素出现的个数

实例：

name_tuple = ('alex','eric','alex','hhh')
print(name_tuple.count("alex"))
2

def index(self, value, start=None, stop=None): # 获取指定元素的索引位置

实例：

name_tuple = ('alex','eric','alex','hhh')
print(name_tuple.index("hhh"))
3

 六、字典

特征：无序的，不支持切片

1、创建字典：

user_info = {"name":"wang",'age':25}
或者
user_info = dict({"name":"wang",'age':25})

2、常用操作：

• 索引
• 新增
• 删除
• 键、值、键值对
• 循环
• 长度

索引

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}

print(user_info["name"])
alex
print(user_info["age"])
22
print(user_info["gender"])
Man

删除

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
print(user_info)
{'gender': 'Man', 'name': 'alex', 'age': 22}
del user_info["age"]
print(user_info)
{'gender': 'Man', 'name': 'alex'}

循环

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
##循环,默认输出key
for i in user_info:
    print(i)
age
gender
name

 键、值、键值对

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}

#获取所有的键
print(user_info.keys())
dict_keys(['age', 'gender', 'name'])
#获取所有的值
print(user_info.values())
dict_values([22, 'Man', 'alex'])
#获取所有的键值对
print(user_info.items())
dict_items([('age', 22), ('gender', 'Man'), ('name', 'alex')])

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
for i in user_info.keys():
    print(i)
name
gender
age

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
for i in user_info.values():
    print(i)
alex
Man
22

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
for k,v in user_info.items():
    print(k)
    print(v)
name
alex
gender
Man
age
22

 三、字典内置方法

def clear(self): #清除字典所有元素

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
user_info.clear()
print(user_info)
{}

def copy(self): # 拷贝字典

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
user_info1 = user_info.copy()
print(user_info1)
{'name': 'alex', 'age': 22, 'gender': 'Man'}####直接赋值和 copy 的区别

dict = { 'name':'alex','age':25,'sex':'man','bobby':[1,2,3]}
dict1 = dict
dict2 = dict.copy()
##修改数据
dict['name']='root'
dict['bobby'].remove(3)
#输出结果
#实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改
print(dict)
{'name': 'root', 'age': 25, 'bobby': [1, 2], 'sex': 'man'}
print(dict1)
{'name': 'root', 'age': 25, 'bobby': [1, 2], 'sex': 'man'}
print(dict2)
{'name': 'alex', 'age': 25, 'bobby': [1, 2], 'sex': 'man'}

def fromkeys(*args, **kwargs): #用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

实例：

seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print(dict)
{'name': None, 'sex': None, 'age': None}

 

seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq, 10)
print(dict)
{'name': 10, 'sex': 10, 'age': 10}

 def get(self, k, d=None): # 根据key获取值，如果key不存在，可以指定一个默认值

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
val = user_info.get("age")
print(val)
22

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
val = user_info.get("age111",'123')
print(val)
123

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
##索引取值时，key不存在就会报错
print(user_info['age'])
22
print(user_info['age111'])
KeyError: 'age111'

def items(self): # 以列表返回可遍历的(键, 值) 元组数组

实例： 

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
print(user_info.items())
dict_items([('age', 22), ('gender', 'Man'), ('name', 'alex')])
##for循环输出
for i,j in user_info.items():
    print(i,":\t",j)
age :     22
gender :     Man
name :     alex

def keys(self): #以列表返回一个字典所有的键。

 实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
print(user_info.keys())
dict_keys(['age', 'gender', 'name'])

def has_key(self):#检查字典中指定key是否存在，适用于Python2.X，Python3没有此方法

key in dict ：#key是否在字典中，是返回True

实例：

##python3.X 中没有has_key，可以使用in代替

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
ret= "age" in user_info.keys()
print(ret)
True
ret= "ag" in user_info.keys()
print(ret)
False

 def pop(self, k, d=None): #移除字典中指定的键值对

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
print(user_info)
{'age': 22, 'name': 'alex', 'gender': 'Man'}
user_info.pop("age")
print(user_info)
{'name': 'alex', 'gender': 'Man'}

def popitem(self): #随机删除一对键值,因为在字典中没有顺序，都是无序的，在工作时如果遇到需要逐一删除项的工作，用popitem()方法效率很高

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
print(user_info)
{'gender': 'Man', 'age': 22, 'name': 'alex'}
user_info.popitem()
print(user_info)
{'age': 22, 'name': 'alex'}

def setdefault(self, k, d=None): # 和get()方法类似, 如果键已经不存在于字典中，将会添加键并将值设为默认值。
实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
print(user_info.setdefault("name",None))
alex
print(user_info.setdefault("like",None))
None

def update(self, E=None, **F): #更新，将其他字典的键值对更新进去
实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
test = {
    "ss" : "23",
    "a2" : "sf"
}
print(user_info)
{'gender': 'Man', 'name': 'alex', 'age': 22}
user_info.update(test)
print(user_info)
{'ss': '23', 'gender': 'Man', 'age': 22, 'a2': 'sf', 'name': 'alex'}

def values(self): #以列表返回字典中的所有值。

实例：

user_info = {
      "name":"alex",
      "age":22,
      "gender":"Man"
}
print(user_info.values())
dict_values(['Man', 22, 'alex'])

其他                                                                                     

1、enumrate

为可迭代的对象添加序号

#enumerate自动生成一列，默认从零开始
li = ["电脑","笔记本","键盘","CD"]
for key,item in enumerate(li):
    print(key,item)
0 电脑
1 笔记本
2 键盘
3 CD

#enumerate自动生成一列，指定从1开始
li = ["电脑","笔记本","键盘","CD"]
for key,item in enumerate(li,1):
    print(key,item)
1 电脑
2 笔记本
3 键盘
4 CD

li = ["电脑","笔记本","键盘","CD"]
for key,item in enumerate(li,1):
    print(key,item)
inp = input("请输入商品：")
# 将字符转换int
inp_num = int(inp)
print(li[inp_num - 1])

1 电脑
2 笔记本
3 键盘
4 CD
请输入商品：2
笔记本

2、range和xrange（2.7）

 xrange,用来获取指定范围内的数，range(0,100000) 用到的时候才会创建到内存中,适用于Python2.7

for i in xrange(1,4):
     print(i)
1
2
3

#range,用来获取指定范围内的数，range(0,100000) 会在内存中一下全部创建出来，适用于Python3.X

print(range(1,4))
for i in range(1,4):
    print(i)
1
2
3

# #第三个数字2是间隔

for i in range(1,10,2):
    print(i)
1
3
5
7
9

##倒着输出

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

li = ['alex','eirc']

li_len = len(li)
for i in range(0,li_len):
    print(i,li[i])
0 alex
1 eirc