Python之路-变量和基本数据类型
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python之路-变量和基本数据类型相关的知识，希望对你有一定的参考价值。
一、注释
注释的作用：
增加程序的可读性
作为调试用
提高团队的合作效率
注释的分类
1、单行注释
以井号（#）开头，右边的所有内容当做说明
2、多行注释
以三对单引号（’’’注释内容’’’）将注释包含起来
其他语法
Python的语法比较简单，采用缩进的方式。
# print absolute value of an integer:
a = 100
if a >= 0:
print(a)
else:
print(-a)
上面代码中，以‘# ’是注释的标识符，可以记录当前代码所代表的意义，解释器会自动忽略这部分内容。
当语句以‘：’结尾时，缩进语句视为代码块。
在Python中，通常我们以4个空格的缩进来进行区分。可以在每句结束之后加一个‘;’号。通常在Python中，默认以换行为新的一行，若想在一行输入多句语句，一定要加‘;’，否则报错。
注意： 由于Python采用缩进的语法，在你复制，粘贴语句时，一定要注意，重新检查当前代码的缩进格式。 在Python中，对大小写十分敏感，如果大小写错误，会报错。
二、变量
标识符
什么是标识符
标识符是自己定义的,如变量名 、函数名等
标识符命名规则
1、只能包含字母、数字和下划线。变量名可以以字母或者下划线开头。但是不能以数字开头。
2、不能包含空格，但可以使用下划线来分隔其中的单词。
3、不能使用Python中的关键字作为变量名
4、建议使用驼峰命名法，驼峰式命名分为大驼峰（UserName）。和小驼峰（userName）。
常用关键字
系统有一些常用关键字不可以用来当做标识符。
在Python中查看
import keyword print(keyword.kwlist)
[\'False\', \'None\', \'True\', \'and\', \'as\', \'assert\', \'break\', \'class\', \'continue\', \'def\', \'del\', \'elif\', \'else\', \'except\', \'finally\', \'for\', \'from\', \'global\', \'if\', \'import\', \'in\', \'is\', \'lambda\', \'nonlocal\', \'not\', \'or\', \'pass\', \'raise\', \'return\', \'try\', \'while\', \'with\', \'yield\']
三、数据类型
Number
int:
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样。
float:
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。
complex:
一个实数和一个虚数的组合构成一个复数。
bool:
bool值是特殊的整型，取值范围只有两个值，也就是True和False。
字符串
字符串就是一系列任意文本。Python中的字符串用单引号或者双引号括起来，同时可以使用反斜杠（\\）转义特殊字符。
单引号（’’）和双引号（"”）本身只是一种表示方式，不是字符串的一部分，因此，字符串’hello’只有h,e,l,l,o这五个字符。如果’本身也是字符的话，那么就可以用””括起来，比如”I’m OK” 当中包含了一个 ’ 。如果字符串内部包含 ’ 或者 ” ，但是又想当成普通字符串处理怎么办？这个时候就要用转义字符（\\）来标识。
操作字符串
截取字符串语法：变量[开始下标：结束下标]
加号（+）是字符串的连接符
星号（*）表示复制当前字符串
格式化输入
通过它能够完成从键盘获取数据，然后保存到指定的变量中 input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存
格式化输出
常用的格式符号:%[(name)][flags][width].[precision]typecode
字符串下标与切片
下标就是编号,字符串实际是字符的组合。
声明一个字符串str1值为：abcd
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]
字符串常用函数
字符串练习：
# -*- coding:utf-8 -*-
\'\'\'
格式化输出
\'\'\'
# name = \'joe\'
# age = 18
# address = \'上海\'
# print(\'大家好我叫%s，我今年%d岁，我来自%s\'%(name,age,address))
# print(\'大家好我叫%s\'%name)
\'\'\'
字符串常用函数
\'\'\'
#find
# str = \'I love python\'
# print(str.find(\'o\'))#返回的是该字符的位置
# print(str.find(\'w\')) #没有的化返回-1
#index
# str = \'I love python\'
# print(str.index\'o\'))#返回的是该字符的位置
# print(str.index(\'o\')) #没有的化返回报错信息
#count
# str = \'I love python\'
# print(str.count(\'o\'))#返回的是该字符出现的次数
# print(str.index(\'o\',2,6)) #在指定位置查找出现的次数
#replace
# str = \'I love python\'
# print(str.replace(\'p\',\'P\'))#替换并输出 I love Python
#split
# str = \'I love python o\'
# print(str.split(\' \'))#指定字符切分 [\'I\', \'love\', \'python\', \'o\']
#capitalize
# str = \'i love python o\'
# print(str.capitalize()) #将字符串的首字母大写I love python o
#capitalize
# str = \'i love python o\'
# print(str.title()) #将字符串中每个单词的的首字母大写I Love Python O
#startswith
# str = \'i love python o\'
# print(str.startswith(\'i\')) #检测字符串是否以指定的字符开头 是则返回True 否则False
#swith
# str = \'i love python o\'
# print(str.endswith(\'p\')) #检测字符串是否以指定的字符结尾 是则返回True 否则False
#upper
# str = \'i love python o\'
# print(str.upper()) #所有字母转化为大写
#lower
# str = \'I LOVE PYTHON O\'
# print(str.lower()) #字符串转化为小写
#ljust
# str = \'hello\'
# print(str.ljust(10)) #返回一个原字符串左对齐，并使用空格填充至长度width的新字符串hello
#rjust
# str = \'hello\'
# print(str.rjust(10)) #返回一个原字符串右对齐，并使用空格填充至长度width的新字符串 hello
#center
# str = \'hello\'
# print(str.center(10)) #返回一个原字符串居中，并使用空格填充至长度width的新字符串 hello
#lstrip
# str = \' hello\'
# print(str.lstrip()) #除去字符串左边的空白字符hello
#rstrip
# str = \'hello \'
# print(str.rstrip()) #除去字符串右边的空白字符hello
#partition
# str = \'hello world hello china\'
# print(str.partition(\'world\')) #可以将字符串以str进行分割成三部分 str前，str,str后(\'hello \', \'world\', \' hello china\')
#join
# str = \'hello world hello china\'
# str1 = \'-\'
# print(str1.join(str)) #str中每个字符后面插入str1,构造出新的字符串h-e-l-l-o- -w-o-r-l-d- -h-e-l-l-o- -c-h-i-n-a
#isspace
# str = \'hello world hello china\'
# print(str.isspace()) #如果str中只包含空格，则返回true 否则返回false
#isalnum
# str = \'hello\'
# print(str.isalnum()) #如果str中所有字符都是字母或者数字，则返回true 否则返回false
#isdigit
# str = \'8765\'
# print(str.isdigit()) #如果str中只包含数字，则返回true 否则返回false
#isalpha
str = \'hello china\'
print(str.isalpha()) #如果str中所有字符都是字母，则返回true 否则返回false
列表
列表写在[ ]内，元素之间用逗号隔开：
注意：
List写在方括号之间，元素用逗号隔开
和字符串一样，List可以被索引和切片
List可以使用加号（+）操作进行拼接
List中的元素是可以被改变的
列表的访问：
列表是由一系列按特定顺序排列的元素组成，列表能存储多种类型的数据，其中的元素之间可以没有任何关系
列表索引
列表的操作：
修改列表元素
修改列表元素的语法和访问列表元素的语法类似，指定列表名和要修改元素的索引，再指定新值
以下列表名为：students，需要将jack修改为tom
添加列表元素1：
在列表末尾追加元素：使用append()方法将元素追加到列表的末尾。也可以用append()方法来动态创建列表
以下列表名为：students，需要将‘篮球添加到列表的末尾’，使用append()方法
添加列表元素2：
在列表中插入元素：通过指定新元素的索引和值，使用insert()方法可以在列表的任何位置添加新元素
以下列表名为：students，需要将‘音乐插入到男的后面，使用insert()方法
删除列表元素
使用pop()方法删除元素：pop方法用于移出列表中的一个元素（默认是最后一个元素），可以指定元素索引，并且返回该元素的值。
使用del语句删除元素：如果知道要删除的元素在列表中的位置，可使用del语句删除元素，元素一旦被删除之后就再无法访问
使用remove()方法删除元素：当不知道元素索引，只知道元素值的时候，使用remove()方法删除元素
查找列表元素
所谓的查找，就是看看指定的元素是否存在
in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false
Python列表函数
列表练习：
# -*- coding:utf-8 -*-
#列表：是由一系列特定顺序排列的元素组成
# 列表可以存储多种类型的数据，
# 元素之间没有任何关系
\'\'\'
访问列表
\'\'\'
# list01 = [\'jack\',\'jane\',\'joe\',\'black\',\'\']
# print(list01[2]) #通过下标访问
#二维列表
# list02 = [\'jack\',\'jane\',[\'leonado\',\'joe\'],\'black\',\'\']
# print(list02[2])
# print(list02[2][0]) #获取leonado
# list02 = [\'jack\',\'jane\',[\'leonado\',\'joe\'],\'black\',\'\']
# list02[0] = \'lili\' #通过下标获取到元素，并且给其赋新的值
# list02[2][0] = \'susan\'
# print(list02)
#列表是一个可变的类型数据，允许我们对其里面的数据进行修改
\'\'\'
列表的操作-追加
append列表末尾追加
insert指定位置插入
\'\'\'
#append
# list02 = [\'jack\',\'jane\',\'joe\']
# list02.append(\'susam\')
# print(list02)
#insert
# list02 = [\'jack\',\'jane\',\'joe\',\'black\']
# print(\'插入之前\')
# print(list02)
# print(\'_\'*20)
# #指定位置插入
# list02.insert(1,\'susan\')
# print(list02)
\'\'\'
删除元素
pop默认从最后删除,还可以通过指定索引删除
del通过指定位置删除
remove通过值删除
# \'\'\'
# list02 = [\'jack\',\'jane\',\'joe\',\'black\']
# print(\'删除之前\')
# print(list02)
# print(\'_\'*20)
# print(list02.pop()) #执行删除操作 并且返回删除的元素
# print(list02)
# print(\'继续删除\')
# print(\'_\'*20)
# print(list02.pop(1)) #执行删除操作 并且返回删除的元素
# print(list02)
#del
# list02 = [\'jack\',\'jane\',\'joe\',\'black\']
# print(\'删除之前\')
# print(list02)
# print(\'_\'*20)
# del list02[1] #指定索引删除 彻底删除
# del list02 #默认将整个列表 从内存中彻底删除，
# print(list02)
#remove 在不知道下标，但是知道具体值的时候通过值来删除
# list02 = [\'jack\',\'jane\',\'joe\',\'black\']
# print(\'删除之前\')
# print(list02)
# print(\'_\'*20)
# list02.remove(\'jane\') #通过元素的值进行删除
# print(list02)
\'\'\'
查找元素是否存在
in
not in
\'\'\'
# list02 = [\'jack\',\'jane\',\'joe\',\'black\']
# name = \'jack\'
# name2 = \'lee\'
# print(name in list02)
# print(name2 in list02)
# list02 = [\'jack\',\'jane\',\'joe\',\'black\']
# name = \'jack\'
# name2 = \'lee\'
# print(name not in list02)
# print(name2 not in list02)
# -*- coding:utf-8 -*-
\'\'\'
列表函数
\'\'\'
# list05 = [\'jack\',\'jane\',\'joe\',\'black\',\'12\']
# #查看列表长度 返回列表元素个数
# print(len(list05)) #类似于一个方法，将参数传入
# list05 = [\'jack\',\'jane\',\'joe\',\'black\'] #如果是字符类型，取字母靠后的
# list05 = [1,52,23,58,100] #默认数值输出结果，取最大值。
# print(max(list05)) #类似于一个方法，将参数传入
# list05 = [\'jack\',\'jane\',\'joe\',\'black\'] #如果是字符类型，取字母靠迁的
# list05 = [1,52,23,58,100] #默认数值输出结果，取最小值。
# print(min(list05)) #类似于一个方法，将参数传入
# list05 = [\'jack\',\'jane\',\'joe\',\'black\',\'joe\',\'jane\']
# print(list05.count(\'joe\')) #统计元素出现的次数
# list05 = [\'jack\',\'jane\',\'joe\',\'black\']
# list06 = [\'aaa\',\'bc\']
# list05.extend(list06) #扩展列表 在一个列表末尾一次性追加一个新列表 传入参数为一个列表 类似于单个元素使用append追加
# print(list05.extend(list06)) #必须先追加再输出
# print(list05)
# list05 = [\'jack\', \'jane\', \'joe\', \'black\',\'joe\']
# print(list05.index(\'joe\')) #从一个列表中找出某一个值第一次出现的位置的索引
# list05 = [\'jack\', \'jane\', \'joe\', \'black\',\'joe\']
# list05.reverse() #对列表中的元素做反向旋转
# print(list05)
# print(list05.reverse()) #不可以在输出里面做旋转，必须先反向旋转再单独输出 和追加extend一样
# list06 = [2,3,5,9,6,12,40]
# list06.sort() #对列表进行排序
# \'print(list06.sort()) #先做排序 在输出
# print(list06)
# list05 = [\'jack\', \'jane\', \'joe\', \'black\',\'joe\']
# list05.clear() #用于清空列表
# print(list05)
# list05 = [\'jack\', \'jane\', \'joe\', \'black\',\'joe\']
# list07 = list05.copy() #复制列表
# print(list07)
#
# list = [\'lee\',\'jone\',\'jack\']
# list.insert(0,\'teacher\')
# list.insert(list.__len__(),\'bzr\')
# print(list)
# # print(list.__len__())
# print(list[1][3])
元组
元祖写在小括号内，元素之间用逗号隔开
注意：
tuple的元素不可改变，但是可以包含可变的对象，比如list
构造包含0个或者1个元素的元祖有特殊语法规则：
tuple1=() #空元祖
tuple2=(1,) #一个元素，需要在元素后添加逗号
访问元组：
元组索引：以下元组成名为students，要访问元祖中的tom
删除元组
元祖和列表不一样，元祖中的元素值是不允许被单独修改和删除的，但是我们可以使用del语句来删除整个元祖
删除元祖语法： del 元组名
元组截取
元组的元素虽然不能够被改变，但是元组也是一个序列，也可以通过索引去访问和截取元组中指定位置的元素
以下元组名为：students，需要截取students的前三个元素
多维元组
多维元祖就是元祖中的元祖，元祖中的元素可以是一个新的元祖
以下列元祖为：students，需要获取元祖中的tom
Python元祖函数
元祖练习：
# -*- coding:utf-8 -*-
\'\'\'
Python 里面的元祖和列表类似，不同之处在于元祖中的元素不能被修改，而列表中的元素可以被修改
也可以进行分片和连接。元祖使用小括号，列表使用方括号。
\'\'\'
\'\'\'
元祖 不可修改 提供了删除del 彻底删除（没法通过下标删除）
元祖中的元素虽然不能被改变，但是元祖也是一个序列，也可以通过索引去访问和截取元祖指定位置的元素
多维元祖：元祖中的元祖
\'\'\'
# tup01 = (1,2,3,4,5)
# print(tup01[3])
\'\'\'
元祖函数：
\'\'\'
# tup01 = (1,2,3,4,5)
# print(len(tup01)) #计算元祖中元素的个数
# tup01 = (1,2,3,4,5)
# print(max(tup01)) #计算元祖中最大的元素
# tup01 = (1,2,3,4,5)
# print(min(tup01)) #计算元祖中最小的元素
# list = [\'jack\',\'joe\',\'black\']
# print(type(list))
# print(tuple(list)) #将列表转化为元祖
# print(type(tuple(list)))
# tup01 = (1,2,3,4,5)
# print(list(tup01)) #将元祖转为列表 可以实现对元祖的修改
字典
字典是一种映射类型，使用{ }表示，他是一个无序的键（key）值（value）对集合
字典是另外一种可变容器类型，且可以存储任意类型对象。
列表元素进行修改的话，通过索引进行修改，如果当前元素的顺序发生改变，此时还需要修改索引才能成功完成元素的修改.
字典既能存储多个数据，又能很方便准确的定位元素呢
字典创建语法：字典的创建使用{}，每个键值（key=>value）对用冒号（：）分割，每对之间用逗号（,）分割。
访问字典
字典中根据键访问值，可以指定自点名和放在方括号内的键。以下字典想要获取学员姓名。
字典：students={\'name\':\'tom\',\'age\':18,\'sex‘:’男\'}
修改字典元素
字典元素也是可以修改的，通过key找到具体元素之后，给一个新的元素值即可。
如：以下字典将学员的年龄修改为20
字典：students={\'name\':\'tom\',\'age\':18,\'sex‘:’男\'}
添加元素
动态的向字典中添加元素的时候，只要添加的键在字典中不存在，就会新增这个元素。
在以下字典中添加一个住址信息
字典：students={\'name\':\'tom\',\'age\':18,\'sex\':\'男\'}
删除字典元素
使用del语句删除元素：del既可以删除指定的字典元素(列表也可以指定)，也可以删除整个字典，如果不指定key，代表删除整个字典。
语法如下：
del 字典名[key]
使用clear()方法清空整个字典：被清空的字典最后会剩下一个空的字典在，而用del删除的字典在程序当中就不存在了。语法如下：
字典名.clear()
注意：
字典是一种映射类型，它的元素是键值对
键(key)必须使用不可变类型（字符串、数值、元组），在同一个字典中，键必须是唯一的。
创建空字典使用{ }
字典函数：
字典方法：
字典练习：
# -*- coding:utf-8 -*-
\'\'\'
字典是用户自己创建索引 通过前面的下标操作
\'\'\'
# dict = {\'name\':\'job\',\'age\':18,\'address\':\'上海\'}
# print(dict)
#访问
# print(dict[\'name\'])
#修改
# dict = {\'name\':\'job\',\'age\':18,\'address\':\'上海\'}
# dict[\'name\'] = \'jack\'
# print(dict)
#添加元素
# dict = {\'name\':\'job\',\'age\':18,\'address\':\'上海\'}
# dict[\'hobby\'] = \'足球\'
# print(dict)#多次运行发现输出的顺序不一样，不一定在最后
#删除
# dict = {\'name\':\'job\',\'age\':18,\'address\':\'上海\'}
# del dict[\'address\'] #删除某一个
# del dict #整个字典彻底从内存删除 表名都不存在了
# print(dict)
# dict = {\'name\':\'job\',\'age\':18,\'address\':\'上海\'}
# dict.clear()
# print(dict) #{} 清空所有元素
\'\'\'
字典函数
\'\'\'
# dict = {\'name\':\'job\',\'age\':18,\'address\':\'上海\'}
# print(len(dict)) #计算字典中元素的个数
# dict = {\'name\':\'job\',\'age\':18,\'address\':\'上海\'}
# print((str(dict)) #输出字典，以可打印的字符串表示。转为str类型
# print(type(str(dict)))
#dict.fromkeys(seq[,]value)
#创建一个新的字典，以seq中的元素作为字典的前半部分的key值,value为字典所有键对应的默认初始化的值
# seq = (\'name\',\'age\',\'sex\')
# dict01 = dict.fromkeys(seq)
# print(\'新字典为：\',dict01)
# dict02 = dict.fromkeys(seq,\'jack\') #对vlue赋值
# print(\'新字典为：\',dict02)
#dict.get(key,default=None)
#返回指定键的值 如果不在字典里面返回default值
# dict = {\'name\':\'job\',\'age\':18,\'address\':\'上海\'}
# print(\'age键的值为：\',dict.get(\'age\'))
# print(\'sex键的值为：\',dict.get(\'sex\')) #没有返回默认none
# print(\'sex键的值为：\',dict.get(\'sex\',\'男\')) #字典里面没有可以手动指定
# print(\'ddress键的值为：\',dict.get(\'ddress\',\'北京\'))#如果建值字典里面有，但是自己手动指定则已手动指定的输出
#key in dict
#如果键在字典dict里面返回true,否则返回false
# dict = {\'name\':[\'job\',\'tom\'],\'age\':18,\'address\':\'上海\'}
# if \'age\' in dict:
# print(\'键age在字典里面存在\')
# else:
# print(\'键age不在字典里面存在\')
# dict.keys()
# 以列表形式返回字典里面所有的键 值
# dict = {\'name\':[\'job\',\'tom\'],\'age\':18,\'address\':\'上海\'}
# print(dict.keys()) #dict_keys([\'age\', \'address\', \'name\'])
# print(dict.values()) #dict_values([18, [\'job\', \'tom\'], \'上海\'])
# dict = {\'name\':[\'job\',\'tom\'],\'age\':18,\'address\':\'上海\'}
#以键值对形式保存在列表中
# print(dict.items()) #dict_items([(\'address\', \'上海\'), (\'age\', 18), (\'name\', [\'job\', \'tom\'])])
集合（无序）
集合set是基本数据类型的一种，它有可变集合(set)和不可变集合(frozenset)两种。创建集合set、集合set添加、集合删除、交集、并集、差集的操作都是非常实用的方法。
浅拷贝与深拷贝
可变(mutable)参数和不可变(immutable)参数
Python中string、tuple和number是不可变对象，而dict、list等是可变对象；不可变对象在进行重新赋值的时候，实际上是将原始值丢弃，将变量指向一个新值；可变对象的可变性实质上是指更改可变对象中的子对象，比如list中的item元素的更改。
直接赋值：其实就是对象的引用（别名)。
代码：
#直接赋值
# a = [1,2,3]
# b = a
# print(a)
# print(b)
# print(id(a))#通过id查看变量在内存中的地址
# print(id(b))
# a[0] = 5
# print(a)
# print(b)
浅拷贝：不拷贝子对象(针对子对象中的item)，当子对象进行更改的时候，原始对象也会改变。
常见操作：列表的切片[:]操作、list()操作，字典的copy()函数、copy模块的copy()函数（两个一模一样的双胞胎）
# #浅拷贝 切片 只拷贝父类
# a = [1,2,3]
# b = [11,22,33]
# c = [111,222,333]
#
# list01 = [a,b,c]
# print(id(list01))
# list02 = list01[:]
# #查看list01和list02
# print(list01)
# print(list02)
# #检查List01和list02在内存中的地址
# print(\'_\'*20)
# print(id(list01))
# print(id(list02))
#
# #修改一下
# a[0] = 5
# print(a)
# print(\'_\'*20)
# print(list01)
# print(list02)#一起改变 因为都指向了同一个子元素
深拷贝：会拷贝子对象，当对原始对象子对象进行更改的时候，原始对象不会改变。
常见操作：copy模块的deepcopy()函数
练习：
#深拷贝 引入copy模块 从父到子 递归一起拷贝了
import copy
a = [1,2,3]
b = [11,22,33]
c = [111,222,333]
list01 = [a,b,c]
print(id(list01))
# list02 = list01[:]
list02 = copy.deepcopy(list01)
#查看list01和list02
print(list01)
print(list02)
#检查List01和list02在内存中的地址
print(\'_\'*20)
print(id(list01))
print(id(list02))
# 修改一下
a[0] = 5
print(a)
print(\'_\'*20)
print(list01)
print(list02)#没有影响 子元素一起复制 list01 list02 各自都有自己的子元素
四、运算符
算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
算术运算符
以下假设变量a=10，变量b=20
赋值运算符
比较运算符
以下假设变量a=10，变量b=20
逻辑运算符
位运算符
a = 60 b = 13
练习：
# -*- coding:utf-8 -*-
\'\'\'
int
\'\'\'
# a = 1
# print(type(a)) #type是python里面用来查看数据类型的函数
\'\'\'
boolean
True 不为零 False 为零
\'\'\'
# a = True
# print(type(a))
\'\'\'
字符串 string
一般使用单引号 或者双引号
\'\'\'
# a = \'刘德华\'
# name= "黎明"
# num = \'1\'
# num2 = \'True\' #带上引号的都是字符串
# print(type(a))
# print(type(name))
# print(type(num))
# str1 = \'"ni hao"\' #双引号成了字符串本身
# print(str1)
# str2 = "\'你 好\'" #单引号成了字符串本身
# print(str2)
# str3 = \'aaa\\\'bbb\' #最外面的单引号是一对 里面的单引号通过\\转义
# print(str3)
#字符串截取
# str = \'abcdefg\'
# print(str)
# print(str[1:5]) #含头不含尾
# print(str[-1]) #输出g 从最后开始输出
# print(str[2:]) #默认输出到最后
# print(str[:2])
# print(str[1:5:2]) #截取1到5 2是步长 隔一个拿取第二个
# print(str[1:5:1]) #等价于print(str[1:5]) 一个一个拿取
# print(str[::-1]) #反向输出
# print(str[5:2:-1])
#运算符
#+
# num1 = 10
# num2 = 3
# print(num1 + num2)
# print(num1 - num2)
# print(num1 * num2)
# print(num1 / num2)
# print(num1 % num2)
# print(num1 // num2) #返回商的整数部分，
# print(num1 ** num2) #幂 num1的num2次幂
\'\'\'
赋值运算
\'\'\'
# str = \'a\'
# num = 1
# num += 1 #num = num + 1 先加
# print(num)
# num = 10
# num -= 1 #num = num - 1 先减
# num *= 2 #num = num * 2
# num /= 2 #num = num / 2
# num %= 2 #num = num % 2
# num **= 2 #num = num ** 2
# num //= 2 #num = num // 2
# print(num)
\'\'\'
比较运算
\'\'\'
# a = 10
# b = 5
# print(a == b)
# print(a != b)
# print(a > b)
# print(a < b)
# print(a >= b)
# print(a <= b)
\'\'\'
逻辑运算
\'\'\'
#and
# a = 10
# b = 5
# print(a > b and a < b) #两个条件为真，则为真，否则为假
# print(a > b or a < b) #两个条件有一个为真，则为真
# print(not a > b) #非
# str = \'\' #空的字符串返回 bool False
# str = [] #空的列表返回 bool False
# str = () #空的元组返回 bool False
# str = {} #空的字典返回 bool False
# str = 0 #0 返回 bool False
# print(bool(str))
\'\'\'
位运算
\'\'\'
a = 4
b = 2
\'\'\'
十进制：1，2,3,4,5,6,7,8,9,10,11
二进制：0000，0001,0010,0011,0100
0000 0100 表示4
0000 0010 2
$ 0000 0000 0 #对应位同时为1则为1 否则为0
| 0000 0110 6
\'\'\'
#按位与运算符 &
#参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0
# print(a & b ) #0
#按位或运算符 |
#参与运算的两个值，只要对应的两个二进制有一个为1，则该位的结果为1
# print(a | b) #6
#按位异或运算符 ~
#参与运算的两个值，当对应的两个二进制相异时，则该位的结果为1
# print(a ^ b)
#按位取反运算符~
#对数据的每个二进制取反，即把1变为0，把0变为1
# print( ~ a ) # -4-1 -5 (取负数 再减1)
#左移运算符 <<
#运算数的各二进位全部左移若干位，由"<<"右边的数字决定移动的位数
#高位丢弃，低位补0
#右移运算符 >>
#把“ >>”左边的运算数的各二进位全部右移若干位，由">>"右边的数字决定移动的位数
以上是关于Python之路-变量和基本数据类型的主要内容，如果未能解决你的问题，请参考以下文章