1、使用Anaconda3520的python3.6解释器 2、解决Pycharm使用turtle时窗口出现闪退的问题，在代码结尾加上:turtle.done()
在Python 中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。
变量通过地址引用了“对象”。 变量位于：栈内存（压栈出栈等细节，后续再介绍）。对象位于：堆内存。 Python 是动态类型语言：变量不需要显式声明类型。根据变量引用的对象，Python 解释器自动确定数据类型。Python 是强类型语言：每个对象都有数据类型，只支持该类型支持的操作。最简单的表达式就是字面量。比如：
a = 123运行过程中，解释器先运行右边的表达式，生成一个代表表达式运算结果的对象；然后，将这个对象地址赋值给左边的变量。 变量my_name 在被使用前未做赋值，因此报错：’my_name’is not defined。
可以通过del 语句删除不在使用的变量。 如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间。
链式赋值用于同一个对象赋值给多个变量。 x=y=123 相当于： x=123; y=123
系列数据赋值给对应相同个数的变量（个数必须保持一致） a,b,c=4,5,6 相当于： a=4;b=5;c=6
Python 不支持常量，即没有语法规则限制改变一个常量的值。我们只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改。
>>> MAX_SPEED = 120 >>> print(MAX_SPEED) 120 >>> MAX_SPEED = 140 #实际是可以改的。只能逻辑上不做修改。 >>> print(MAX_SPEED) 140每个对象都有类型，python 中内置的“基本数据类型”：
整型(int) 整数，2345,10,50浮点型(float) 小数，3.14 或者科学计数法314e-2布尔型(bool) 表示真假，仅包含：True、False字符串型(string) 由字符组成的序列。“abc”,”sxt”,“IT学堂”Python 支持整数(如：50,520)和浮点数(如：3.14,10.0, 1.23e2)，我们可以对数字做如下运算。
divmod()是一个函数，他返回的是一个元组。
Python 中，除10 进制，还有其他三种进制：
0b 或0B，二进制0 10o 或0O，八进制0 1 2 3 4 5 6 70x 或0X，十六进制0 1 2 3 4 5 6 7 8 9 a b c d e f【操作】测试不同进制
>>> 12 12 >>> 0b101 5 >>> 0o19 SyntaxError: invalid syntax >>> 0o10 8 >>> 0xff 255 >>> 0xf 15 >>> 0x10 16整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是10.0
Python2 中，int 是32 位，可以存储从-2147483648 到2147483647 的整数（约±21 亿）。Long 类型是64 位，可以存储：-263–263-1 之间的数值。 Python3 中，int 可以存储任意大小的整数，long 被取消。我们甚至可以存储下面的值：
>>> googol = 10**100 >>> googol 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000Googol 也是Google 最初的名字，这也是Google 最初的含义。 Python3 中可以做超大数的计算，而不会造成“整数溢出”，这也是Python 特别适合科学运算的特点。
浮点数，称为float。浮点数用a×b10 形式的科学计数法表示。比如：3.14，表示成：314E-2 或者314e-2。 这些数字在内存中也是按照科学计数法存储。
运算符+、-、*，/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”。 a = a + 1 等价于： a +=1
注意：“+=”中间不能加空格！
计算机中时间的表示是从“1970 年1 月1 日00:00:00”开始，以毫秒（1/1000 秒）进行计算。我们也把1970 年这个时刻成为“unix 时间点”。 这样，我们就把时间全部用数字来表示了。
python 中可以通过time.time() 获得当前时刻，返回的值是以秒为单位，带微秒（1/1000 毫秒）精度的浮点值。例如：1530167364.8566。
>>> import time >>> time.time() >>> 1530168754.4904466 >>> b = int(time.time()) >>> b 1530168754 >>> totalMinutes = b/60 >>> totalMinutes 25502812.566666666 >>> totalMinutes = b//60 >>> totalMinutes 25502812 >>> totalHours = totalMinutes//60 >>> totalHours 425046 >>> totalDays = totalHours//24 >>> totalDays 17710 >>> totalYears = totalDays//365 >>> totalYears 48定义多点坐标_绘出折线_并计算起始点和终点距离
import turtle import math #定义多个点的坐标 x1,y1 = 100,100 x2,y2 = 100,-100 x3,y3 = -100,-100 x4,y4 = -100,100 #绘制折线 turtle.penup() turtle.goto(x1,y1) turtle.pendown() turtle.goto(x2,y2) turtle.goto(x3,y3) turtle.goto(x4,y4) #计算起始点和终点的距离 distance = math.sqrt((x1-x4)**2 + (y1-y4)**2) turtle.write(distance) turtle.done()Python2 中没有布尔值，直接用数字0 表示False,用数字1 表示True。 Python3 中，把True 和False 定义成了关键字，但他们的本质还是1 和0，甚至可以和数字相加。
>>> a = True >>> b = 3 >>> a+b 4所有比较运算符返回1 表示真，返回0 表示假。这分别与特殊的变量True 和False 等价。 以下假设变量a 为15，变量b 为30：
同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。
is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。 == 用于判断引用变量引用对象的值是否相等，默认调用对象的__eq__()方法。
>>> a = 100 >>> b = 100 >>> a == b True >>> a is b True >>> id(a) 1685026976 >>> id(b) 1685026976 >>> a = 1000 >>> b = 1000 >>> a == b True >>> a is b False >>> id(a) 2294176357168 >>> id(b) 2294176358352 >>> a = 100 >>> b = 100 >>> a is b True >>> a = 10000 >>> b = 10000 >>> a is b False >>> id(a) 2294176357296 >>> id(b) 2294176358352 >>> a = 10000 >>> b = a >>> a is b TruePython 仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对象。 需要注意的是，这仅仅是在命令行中执行，而在Pycharm 或者保存为文件执行，结果是不一样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。 总结 1、is 比较两个对象的id 值是否相等，是否指向同一个内存地址； 2、== 比较的是两个对象的内容是否相等，值是否相等； 3、小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用； 4、is 运算符比== 效率高，在变量和None 进行比较时，应该使用is；
同一运算符测试
>>> a = 1000 >>> b = 1000 >>> a == b True >>> a is b False >>> id(a) 46764560 >>> id(b) 46765216 >>> c = 10 >>> d = 10 >>> c is d True >>> id(c) 1388831648 >>> id(d) 1388831648在Python中一切都是对象。Python中对象包含的三个基本要素，分别是：
id(身份标识)type(数据类型)value(值)对象之间比较是否相等可以用 == ，也可以用 is 。
is 和 == 都是对对象进行比较判断作用的，但对对象比较判断的内容并不相同。is 比较的是两个对象的id值是否相等，也就是比较两个对象是否为同一个实例对象，是否指向同一个内存地址。 == 比较的是两个对象的内容是否相等，默认会调用对象的 eq 方法。 == 是python标准操作符中的比较操作符，用来比较判断两个对象的值是否相等。 先来看一个例子 >>> a = [1, 2, 3] >>> b = a >>> b is a True >>> b == a True >>> b = a[:] >>> b is a False >>> b == a Trueis 也被叫做同一性运算符，也就是id是否相同。 看下面代码， a和b变量的id不同， 所以 b == a 是True， b is a 是False. 再来看一下他们的id：
>>> id(a) 4364243328 >>> >>> id(b) 4364202696哪些情况下 is 和 == 结果是完全相同的？
>>> a = 256 >>> b = 256 >>> a is b True >>> a == b True >>> a = 1000 >>> b = 10**3 >>> a == b True >>> a is b False所以数字类型不完全相同。 那为什么256时相同， 而1000时不同呢？ 因为出于对性能的考虑，Python内部做了很多的优化工作，对于整数对象，Python把一些频繁使用的整数对象缓存起来，保存到一个叫 small_ints 的链表中，在Python的整个生命周期内，任何需要引用这些整数对象的地方，都不再重新创建新的对象，而是直接引用缓存中的对象。 Python把这些可能频繁使用的整数对象规定在范围 [-5, 256] 之间的小对象放在 small_ints 中，但凡是需要用些小整数时，就从这里面取，不再去临时创建新的对象。
>>> c = 'miracle.young' >>> d = 'miracle.young' >>> c is d False >>> c == d True >>> c = 'miracleyoung' >>> d = 'miracleyoung' >>> c is c True >>> c == d True所以字符串类型不完全相同，这个和解释器实现有关。
>>> a = (1,2,3) # a和b为元组类型 >>> b = (1,2,3) >>> a is b False >>> a = [1,2,3] # a和b为list类型 >>> b = [1,2,3] >>> a is b False >>> a = {'miracle':100,'young':1} # a和b为dict类型 >>> b = {'miracle':100,'young':1} >>> a is b False >>> a = set([1,2,3]) # a和b为set类型 >>> b = set([1,2,3]) >>> a is b False所以当变量是数字、字符串、元组，列表，字典时，is 和 == 都不相同， 不能互换使用！当比较值时，要使用 ==，比较是否是同一个内存地址时应该使用is。 当然，开发中比较值的情况比较多。
字符串的本质是：字符序列。Python 的字符串是不可变的，我们无法对原字符串做任何修改。但，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。 Python 不支持单字符类型，单字符也是作为一个字符串使用的。
Python3 直接支持Unicode，可以表示世界上任何书面语言的字符。Python3 的字符默认就是16 位Unicode 编码，ASCII 码是Unicode 编码的子集。 使用内置函数ord()可以把字符转换成对应的Unicode 码； 使用内置函数chr()可以把十进制数字转换成对应的字符。
>>> ord('A') 65 >>> ord("魏") 39759 >>> chr(66) 'B'我们可以通过单引号或双引号创建字符串。例如：a=’abc’; b=”sxt” 使用两种引号的好处是可以创建本身就包含引号的字符串，而不用使用转义字符。例如：
>>> a = "I'm a teacher!" >>> print(a) I'm a teacher! >>> b = 'my_name is "TOM"' >>> print(b) my_name is "TOM"连续三个单引号或三个双引号，可以帮助我们创建多行字符串。例如：
>>> resume = ''' name="gaoqi" company="sxt" age=18 lover="Tom"''' >>> print(resume) name="gaoqi" company="sxt" age=18 lover="Tom"空字符串和len()函数 Python 允许空字符串的存在，不包含任何字符且长度为0。例如：
>>> c = '' >>> len(c) 0len()用于计算字符串含有多少字符。例如：
>>> d = 'abc魏先生' >>> len(d) 6我们可以使用“+特殊字符”，实现某些难以用字符表示的效果。比如：换行等。常见的 转义字符有这些： 测试转义字符的使用
>>> a = 'I\nlove\nU' >>> a 'I\nlove\nU' >>> print(a) I love U >>> print('aaabb\ cccddd') aaabbcccddd使用*可以实现字符串复制。 【操作】字符串复制操作
>>> a = 'Sxt'*3 >>> a 'SxtSxtSxt'我们前面调用print 时，会自动打印一个换行符。有时，我们不想换行，不想自动添加换行 符。我们可以自己通过参数end = “任意字符串”。实现末尾添加任何内容： 建立源文件mypy_06.py：
print("sxt",end=' ') print("sxt",end='##') print("sxt")运行结果： sxt sxt##sxt
我们可以使用input()从控制台读取键盘输入的内容。
>>> myname = input("请输入名字:") 请输入名字:魏先生 >>> myname '魏先生'str()可以帮助我们将其他数据类型转换为字符串。例如： str(5.20) > ‘5.20’ str(3.14e2)>’314.0’ str(True) ==> ‘True’ 当我们调用print()函数时，解释器自动调用了str()将非字符串的对象转成了字符串。我们在面向对象章节中详细讲解这部分内容。
字符串的本质就是字符序列，我们可以通过在字符串后面添加[]，在[]里面指定偏移量，可以提取该位置的单个字符。 正向搜索： 最左侧第一个字符，偏移量是0，第二个偏移量是1，以此类推。直到len(str)-1为止。 反向搜索： 最右侧第一个字符，偏移量是-1，倒数第二个偏移量是-2，以此类推，直到-len(str)为止。 【操作】使用[]提取字符串中的字符
>>> a = 'abcdefghijklmnopqrstuvwxyz' >>> a 'abcdefghijklmnopqrstuvwxyz' >>> a[0] 'a' >>> a[3] 'd' >>> a[26-1] 'z' >>> a[-1] 'z' >>> a[-26] 'a' >>> a[-30] Traceback (most recent call last): File "<pyshell#91>", line 1, in <module> a[-30] IndexError: string index out of range字符串是“不可改变”的，我们通过[]可以获取字符串指定位置的字符，但是我们不能改变字符串。我们尝试改变字符串中某个字符，发现报错了：
>>> a = 'abcdefghijklmnopqrstuvwxyz' >>> a 'abcdefghijklmnopqrstuvwxyz' >>> a[3]='高' Traceback (most recent call last): File "<pyshell#94>", line 1, in <module> a[3]='高' TypeError: 'str' object does not support item assignment字符串不可改变。但是，我们确实有时候需要替换某些字符。这时，只能通过创建新的字符串来实现。
>>> a = 'abcdefghijklmnopqrstuvwxyz' >>> a 'abcdefghijklmnopqrstuvwxyz' >>> a = a.replace('c','高') 'ab 高defghijklmnopqrstuvwxyz'整个过程中，实际上我们是创建了新的字符串对象，并指向了变量a，而不是修改了以前的字符串。内存图如下：
切片slice 操作可以让我们快速的提取子字符串。标准格式为：[起始偏移量start：终止偏移量end：步长step]
典型操作(三个量为正数的情况)如下： 其他操作（三个量为负数）的情况：
>>> a = "abcdefg" >>> a[::] 'abcdefg' >>> a[::-1] 'gfedcba'切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于0 则会当做0，终止偏移量大于“长度-1”会被当成-1。例如：
>>> "abcdefg"[3:50] 'defg'我们发现正常输出了结果，没有报错。 【案例】
将”to be or not to be”字符串倒序输出将”sxtsxtsxtsxtsxt”字符串中所有的s 输出 >>> "to be or not to be"[::-1] 'eb ot ton ro eb ot' >>> "sxtsxtsxtsxtsxt"[::3] 'sssss'split()可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)。示例代码如下：
>>> a = "to be or not to be" >>> a.split() ['to', 'be', 'or', 'not', 'to', 'be'] >>> a.split('be') ['to ', ' or not to ', '']join()的作用和split()作用刚好相反，用于将一系列子字符串连接起来。示例代码如下：
>>> a = ['sxt','sxt100','sxt200'] >>> '*'.join(a) 'sxt*sxt100*sxt200'拼接字符串要点：使用字符串拼接符+，会生成新的字符串对象，因此不推荐使用+来拼接字符串。推荐使用join 函数，因为join 函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝，仅新建一次对象。 【操作】测试+拼接符和join()，不同的效率(mypy_07.py)
import time time01 = time.time() # 起始时刻 a = "" for i in range(1000000): a += "sxt" time02 = time.time() # 终止时刻 print("运算时间：" + str(time02 - time01)) # 运算时间：0.5902230739593506 time03 = time.time() # 起始时刻 li = [] for i in range(1000000): li.append("sxt") a = "".join(li) time04 = time.time() # 终止时刻 print("运算时间：" + str(time04 - time03)) # 运算时间：0.1186819076538086字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。 Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制驻留机制。
>>> a = "abd_33" >>> b = "abd_33" >>> a is b True >>> c = "dd#" >>> d = "dd#" >>> c is d False >>> str1 = "aa" >>> str2 = "bb" >>> str1+str2 is "aabb" False >>> str1+str2 == "aabb" True字符串比较和同一性 我们可以直接使用==,!=对字符串进行比较，是否含有相同的字符。 我们使用is / not is，判断两个对象是否同一个对象。比较的是对象的地址，即id(obj1)是否和id(obj2)相等。
成员操作符 in /not in 关键字，判断某个字符(子字符串)是否存在于字符串中。
字符串常用方法汇总 常用查找方法 我们以一段文本作为测试： a=’’‘我是高淇,今年18 岁了,我在北京尚学堂科技上班。我的儿子叫高洛希，他6 岁了。我是一个编程教育的普及者，希望影响6000 万学习编程的中国人。我儿子现在也开始学习编程，希望他18 岁的时候可以超过我’’’
我们可以通过strip()去除字符串首尾指定信息。通过lstrip()去除字符串左边指定信息，rstrip()去除字符串右边指定信息。 【操作】去除字符串首尾信息
>>> "*s*x*t*".strip("*") 's*x*t' >>> "*s*x*t*".lstrip("*") 's*x*t*' >>> "*s*x*t*".rstrip("*") '*s*x*t' >>> " sxt ".strip() 'sxt'编程中关于字符串大小写转换的情况，经常遇到。我们将相关方法汇总到这里。为了方便学习，先设定一个测试变量： a = “gaoqi love programming, love SXT”
center()、ljust()、rjust()这三个函数用于对字符串实现排版。示例如下：
>>> a="SXT" >>> a.center(10,"*") '***SXT****' >>> a.center(10) ' SXT ' >>> a.ljust(10,"*") 'SXT*******'其他方法
isalnum() 是否为字母或数字isalpha() 检测字符串是否只由字母组成(含汉字)。isdigit() 检测字符串是否只由数字组成。isspace() 检测是否为空白符isupper() 是否为大写字母islower() 是否为小写字母 >>> "sxt100".isalnum() True >>> "sxt 尚学堂".isalpha() True >>> "234.3".isdigit() False >>> "23423".isdigit() True >>> "aB".isupper() False >>> "A".isupper() True >>> "\t\n".isspace() Trueformat()基本用法 Python2.6 开始，新增了一种格式化字符串的函数str.format()，它增强了字符串格式化的功能。 基本语法是通过{} 和: 来代替以前的% 。 format 函数可以接受不限个参数，位置可以不按顺序。
>>> a = "名字是:{0},年龄是：{1}" >>> a.format("高淇",18) '名字是:高淇,年龄是：18' >>> a.format("高希希",6) '名字是:高希希,年龄是：6' >>> b = "名字是：{0}，年龄是{1}。{0}是个好小伙" >>> b.format("高淇",18) '名字是：高淇，年龄是18。高淇是个好小伙' >>> c = "名字是{name}，年龄是{age}" >>> c.format(age=19,name='高淇') '名字是高淇，年龄是19'我们可以通过{索引}/{参数名}，直接映射参数值，实现对字符串的格式化，非常方便。
填充常跟对齐一起使用 ^、<、>分别是居中、左对齐、右对齐，后面带宽度 :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
>>> "{:*>8}".format("245") '*****245' >>> "我是{0},我喜欢数字{1:*^8}".format("高淇","666") '我是高淇,我喜欢数字**666***'浮点数通过f，整数通过d 进行需要的格式化。案例如下：
>>> a = "我是{0}，我的存款有{1:.2f}" >>> a.format("高淇",3888.234342) '我是高淇，我的存款有3888.23'其他格式，供大家参考：
在Python 中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，智能创建新的字符串对象。但是，经常我们确实需要原地修改字符串，可以使用io.StringIO对象或array 模块。
>>> import io >>> s = "hello, sxt" >>> sio = io.StringIO(s) >>> sio <_io.StringIO object at 0x02F462B0> >>> sio.getvalue() 'hello, sxt' >>> sio.seek(7) 7 >>> sio.write("g") 1 >>> sio.getvalue() 'hello, gxt'加法操作 (1) 数字相加3+2 > 5 (2) 字符串拼接“3”+“2”> “32” (3) 列表、元组等合并[10,20,30]+[5,10,100] ==>[10,20,30,5,10,100]
乘法操作 (1) 数字相乘3*2 ==> 6 (2) 字符串复制“sxt”*3 ==> ”sxtsxtsxt” (3) 列表、元组等复制[10,20,30]*3 ==> [10,20,30,10,20,30,10,20,30]
复合赋值可以让程序更加精炼，提高效率。 注：与C 和JAVA 不一样，Python 不支持自增(++)和自减(–)
如下优先级，从高到低。 实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。
乘除优先加减位运算和算术运算>比较运算符>赋值运算符>逻辑运算符