python基础之数据类型与变量

一.变量

1 什么是变量之声明变量

#变量名=变量值
age=18
gender1='male'
gender2='female'

2 为什么要有变量

变量作用：“变”=>变化，“量”=>计量/保存状态
程序的运行本质是一系列状态的变化，变量的目的就是用来保存状态，变量值的变化就构成了程序运行的不同结果。

3 变量值之类型与对象

程序中需要处理的状态很多，于是有了不同类型的变量值，x='seven',变量值'seven'存放与内存中，绑定一个名字x，变量值即我们要存储的数据。

在python中所有数据都是围绕对象这个概念来构建的，对象包含一些基本的数据类型：数字，字符串，列表，元组，字典等
程序中存储的所有数据都是对象，
对象三个特性
• 身份：内存地址，可以用id()获取
• 类型：决定了该对象可以保存什么类型值，可执行何种操作，需遵循什么规则，可用type()获取
• 值：对象保存的真实数据
注：我们在定义数据类型，只需这样：x＝1，内部生成1这一内存对象会自动触发，我们无需关心

1 对象的类型也称为对象的类别，python为每个类型都定制了属于该类型特有的方法，极大地方便了开发者对数据的处理
2 创建某个特定类型的对象也称为创建了该类型的一个实例，工厂函数的概念来源于此

4 可变对象与不可变对象

实例被创建后，身份和类型是不可变的，
如果值是不可以被修改的，则是不可变对象
如果值是可以被修改的，则是可变对象

可变数据类型：在id不变的情况下，数据类型内部的元素可以改变，

不可变数据类型：value改变，id也跟着改变(数字、字符串、布尔)

补充  True--->1

　　   False--->0

5 容器对象

某个对象包含对其他对象的引用，则称为容器或集合,Python中可作为容器的有：列表，元组，字典

6 对象的属性和方法

属性就是对象的值，方法就是调用时将在对象本身上执行某些操作的函数，使用.运算符可以访问对象的属性和方法，如
a=3+4j
a.real

b=[1,2,3]
b.append(4)

7 身份比较，类型比较，值比较

x=1

y=1
x is y #x与y是同一个对象，is比较的是id，即身份
type(x) is type(y) #对象的类型本身也是一个对象，所以可以用is比较两个对象的类型的身份
x == y #==比较的是两个对象的值是否相等

8 变量的赋值操作

• 与c语言的区别在于变量赋值操作无返回值
• 链式赋值：y＝x＝a＝1
• 多元赋值：x,y=1,2 x,y=y,x
• 增量赋值：x+=1

二.数据类型

2.2基本数据类型

2.2.1数字：

特性：
1.只能存放一个值
2.一经定义，不可更改
3.直接访问
分类：整型，长整型，布尔，浮点，复数

整型int：年级，年纪，等级，身份证号，qq号，手机号
level=10
Python的整型相当于C中的long型,Python中的整数可以用十进制,八进制,十六进制表示。
>>> 10
10 --------->默认十进制
>>> oct(10)
'012' --------->八进制表示整数时，数值前面要加上一个前缀“0”
>>> hex(10)
'0xa' --------->十六进制表示整数时，数字前面要加上前缀0X或0x
python2.*与python3.*关于整型的区别
python2.*
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
python3.*整形长度无限制

浮点型float：身高，体重，薪资，温度，价格
height=1.81
salary=3.3
Python的浮点数就是数学中的小数，类似C语言中的double。
在运算中，整数与浮点数运算的结果是浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，
一个浮点数的小数点位置是可变的，比如，1.23*109和12.3*108是相等的。
浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，
就必须用科学计数法表示，把10用e替代，1.23*109就是1.23e9，或者12.3e8，0.000012
可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的而浮点数运算则可能会有
四舍五入的误差。

2.2.2字符串

字符串str：它是一个有序的字符的集合，用于存储和表示基本的文本信息，‘’或“”或‘’‘ ’‘’中间包含的内容称之为字符串，包含在引号（单，双，三）里面，由一串字符组成

特性：
1.只能存放一个值
2.不可变
3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
补充：
　　1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'
　　2.unicode字符串与r连用必需在r前面，如name＝ur'l\thf'

用途（描述性的数据）：姓名，性别，地址，学历，密码：alex3714
name='egon'

取值：
首先要明确，字符串整体就是一个值，只不过特殊之处在于：
python中没有字符类型，字符串是由一串字符组成，想取出字符串中
的字符，也可以按照下标的方式取得

name:取得是字符串整体的那一个值
name[1]：取得是第二位置的字符

字符串拼接：
>>> msg1='hello'
>>> msg2=' world'
>>>
>>> msg1 + msg2
'hello world'
>>> res=msg1 + msg2
>>> print(res)
hello world

>>> msg1*3
'hellohellohello'

#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))
print(name.startswith('alex'))

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

#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)

#find,rfind,index,rindex,count
name='egon say hello'
print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index('e',2,4)) #同上,但是找不到会报错
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有

#split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))

name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分

#join
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串

#center,ljust,rjust,zfill
name='egon'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充

#expandtabs
name='egon\thello'
print(name)
print(name.expandtabs(1))

#lower,upper
name='egon'
print(name.lower())
print(name.upper())

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写

#is数字系列
#在python3中
num1=b'' #bytes
num2=u'' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

#is其他
print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母和数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

练习

# 写代码,有如下变量,请按照要求实现每个功能
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6)    将 name 变量对应的值变大写,并输出结果

# 7)    将 name 变量对应的值变小写,并输出结果

# 8)    请输出 name 变量对应的值的第 2 个字符?
# 9)    请输出 name 变量对应的值的前 3 个字符?
# 10)    请输出 name 变量对应的值的后 2 个字符?

# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

# 12)    获取子序列,去掉最后一个字符。如: hello 则获取 hell。

# 写代码,有如下变量,请按照要求实现每个功能
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
name = ' aleX'
a=name.strip()
print(a)

# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

name=' aleX'
if name.startswith(name):
    print(name)
else:
    print('no')

# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

name=' aleX'
if name.endswith(name):
    print(name)
else:
    print('no')

# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
name=' aleX'
print(name.replace('l','p'))

# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
name=' aleX'
print(name.split('l'))

# 6)    将 name 变量对应的值变大写,并输出结果

name=' aleX'
print(name.upper())

# 7)    将 name 变量对应的值变小写,并输出结果

name=' aleX'
print(name.lower())

# 8)    请输出 name 变量对应的值的第 2 个字符?
name=' aleX'
print(name[1])

# 9)    请输出 name 变量对应的值的前 3 个字符?
name=' aleX'
print(name[:3])

# 10)    请输出 name 变量对应的值的后 2 个字符?

name=' aleX'
print(name[-2:])

# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

name=' aleX'
print(name.index('e'))

# 12)    获取子序列,去掉最后一个字符。如: hello 则获取 hell。
name=' aleX'
a=name[:-1]
print(a)

2.2.3列表

定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
特性：
1.可存放多个值
2.可修改指定索引位置对应的值，可变
3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
用途（存多个值，可以修改）：爱好，装备，女朋友们
hobby=['play','eat','sleep']
方法：
hobby.append
hobby.remove
操作：
查看：
>>> girls=['alex','wsb',['egon','ysb']]
>>> girls[2]   #查看第3位的元素
['egon', 'ysb']
>>> girls[2][0]   #查看第3位元素的第一个元素

追加
girls.append(元素)  #在列表最后增加新元素
删除
girls.remove(元素)    #删除指定元素
del girls[元素的索引]   #删除目标索引位置的元素
修改
girls[0]='alexSB'

切片

girls[0:2]  #顾头不顾尾   结果为 ['alex', 'wsb']

girls[0:3:2]  #第三位是指定步长为2，默认不写为1,  结果为 ['alex', ['egon', 'ysb']]

长度

循环

包含in

练习：

　　　　有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

l=[
    {'name':'alex','age':84},
    {'name':'oldboy','age':73},
    {'name':'egon','age':18},
]
l.sort(key=lambda item:item['age'])
print(l)

2.2.4 字典dict

定义：在{}，逗号分割，每一个元素的形式都是key:value
定义：｛key1:value1,key2:value2｝,key-value结构，key必须可hash
特性：
1.可存放多个值
2.可修改指定key对应的值，可变
3.无序

字典：
用途：存多个值，这一点与列表相同，值可以是任意数据类型
特征：每一个值都一个唯一个对应关系，即key，强调一点，key必须是
不可变类型：字符串，数字
student_info={
'age':81,
'name':'alex',
'sex':None,
'hobbies':['zsb0','zsb1','zsb2','zsb30']
}

操作：
查看
>>> student_info={
... 'age':81,
... 'name':'alex',
... 'sex':None,
... 'hobbies':['zsb0','zsb1','zsb2','zsb30']
... }
>>>
>>> student_info['age']
81
>>> student_info['hobbies']
['zsb0', 'zsb1', 'zsb2', 'zsb30']
>>> student_info['hobbies'][2]
'zsb2'

增加
student_info['stu_id']=123456

删除
del student_info['stu_id']

修改
student_info['name']='alexSB'

# 作业三：字典练习
# 　　1
# 有如下值集合[11, 22, 33, 44, 55, 66, 77, 88, 99, 90...]，将所有大于
#
# 的值保存至字典的第一个key中，将小于
#
# 的值保存至第二个key的值中。（2
# 分）
#
# 　　即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
#
# dic={'k1':[],'k2':[]}
# num=[11,22,33,44,55,66,77,88,99,90]
# for i in num :
#     if i >66:
#         dic['k1'].append(i)
#     if i<66:
#         dic['k2'].append(i)
# print(dic)

#2 统计s = 'hello alex alex say hello sb sb'
# 中每个单词的个数
#
# 　　结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
#方法1：
# s = 'hello alex alex say hello sb sb'
# dic={}
# l=s.split()
# for i in l:
#     if i not in dic:
#         dic[i]=1
#     else:
#         dic[i] += 1
# print(dic)

#方法2：利用count重复赋值
# s = 'hello alex alex say hello sb sb'
# dic={}
# l=s.split()
# for word in l:
#     dic[word]=l.count(word)
# print(dic)

#方法3： 利用setdefault
'''
setdefault的功能
1.key存在，则不赋值，key不存在则设置默认值
2.key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) #返回1

d={'a':2222}
print(d.setdefault('a',1)) #返回2222
'''

# s = 'hello alex alex say hello sb sb'
# dic={}
# words=s.split()
# for word in words:
#     dic.setdefault(word,s.count(word))
# print(dic)

#方法4：利用集合，去掉重复，减少循环次数
# s = 'hello alex alex say hello sb sb'
# dic={}
# word=s.split()
# words_set=set(word)
# for word in words_set:
#     dic[word]=s.count(word)
# print(dic)

布尔：True False
用途：用来判断

>>> pinfo={'name':'oldboymei','age':53,'sex':'female'}
>>>
>>>
>>> pinfo['age'] > 50
True
>>> pinfo['sex'] == 'female'
True