Python(一)

IDLE

IDLE是一个PythonShell,（安装结束后在开始菜单键入idle打开）shell的意思就是“外壳”，基本上来说，就是一个通过键入文本与程序交互的途径

关于python

• 在python中，缩进具有语法意义
• 程序块：

  for line in line:
    print("hello")

• 程序块中的每一行用4个空格进行缩进，在程序中，每一个程序块头是循环结构或判断结构的开始
• python被称为块结构语言(block-structured language)，一个程序块可以嵌套在另一个程序块里。
• 程序文档是注释的集合

函数和方法

函数和方法的不同之处

1. 作用域：

• 函数：从函数调用开始至函数执行完成，返回给调用者后，在执行过程中开辟的空间会自动释放，也就是说函数执行完成后，函数体内部通过赋值等方式修改变量的值不会保留，会随着返回给调用者后，开辟的空间会自动释放。
• 方法：通过实例化的对象进行方法的调用，调用后开辟的空间不会释放，也就是说调用方法中对变量的修改值会一直保留。

2. 调用方法：

• 函数：通过“函数名（）”的方式进行调用
• 方法：通过“对象.方法名”的方式进行调用。

3. 参数传递方式

• 函数：显式传递
• 方法：隐式传递

注：方法是一种特殊的函数

数值

处理数值类型的函数

• abs()绝对值函数
• int()保持整数不变，并将浮点数通过丢弃小数部分转换为整数
• round(n,r)四舍五入保留n的小数点后r位

  a = 2
  b = 3
  print(abs(1-(4*b))  #11
  print(int(a**b)+.8) #表示2^3+0.8，结果为8
  print(round(a/b,3))  #0.667

增量赋值

var += n +=可看成执行了一个增量赋值，即 var = var + n，其他增量赋值运算符有-=、=、/=、

num1 = 6
num1 += 1 # 7

num2 =7
num 2 -= 5 #2

num3 = 8
num3 /= 2 #4

num4 = 1
num4 *= 3 #3

num5 = 2
num5 **= 3 #8 表示2^3

python输入输出

print 函数

1. 自动计算

   print(5+3)    #输出为8

2. 连接字符串

   print("hello"+"world")  #输出hellowrold

3. 重复输出

   print("hello world"*8)   #将hello world 重复输出8遍

4. eval/int/float/str函数

   print (int("23.7"))   #23
   print (float("23"))   #23.0
   print (eval("2+3*3"))  #11  eval函数将计算相应表达式，赋值为合适的整型或浮点型

5. end参数
   print(value0,value1,…..,end=endString) 末尾显示endString

   print("hello",end=",")  #末尾显示","，代替换行参数
   print("world")     #hello,world

注：print函数会触发一个换行操作，意味着下一个Print函数的输出将从新的一行开始

变量

python的变量与其他语言不同，python并不把值存储在变量中，而更像把名字贴在值上面（有些python程序员会说Python没有变量，只有名字）

first = 3
second = 2
print(first + second)  #5

注： 1.在使用变量之前要先对其赋值
2.变量不能以数字开头
3.python区分大小写

字符串

字符串字面量是字符构成的一个序列，并视其为一个整体。

文本

字符串也可以叫文本，文本与数字不同
数字

first = 3+5
print(first)  #8

文本

first = '3'+'5'
print(first) #35

转义符号

反斜杠\

\反斜杠 续行符
\r回车
\b退格
\f换页
\n换行

print("let\'s go")

注：计算字符串长度时，每个转义序列当作一个字符。反斜杠不被认为是一个字符，而是指示器告诉python对跟随其后的字符进行特殊处理

原始字符串

str = r'C:\now'   # \n将不会被识别为转义字符

索引和切片

子字符串或切片是字符串中连续字符的一个序列。如果str1是一个字符串，str1[m:n]是以位置m开始，到位置n-1结束的子字符串。

注：若m>=n，即位置m对应的字符串不在位置n对应的字符串左边，则str1[m:n]表示空字符串(“”)。

find/rfind函数

• subStr是一个字符串，str1.find(subStr)表示从左向右搜索字符串str1，并返回subStr首次出现的正向索引位置。
• str1.rfind(subStr)将从右向左搜索字符串，并返回subStr首次出现的正向索引位置。
• 如果subStr不在str1中，则find()/rfind()函数返回值为-1。

  print("python"); #python
  print("python"[1],"python"[5]),"python"[2:4] #y n th
  str1 = "hello world"
  print(str1.find('w'))   #6
  print(str1.find('x'))     #-1
  print(str1.rfind('l'))    #9

反向索引

反向索引最右端的字符索引值为-1，它左边的一个字符索引值为-2，以此类推

print("python")
print("python"[-1],"python"[-5,-2])  #o yth

注：除Python外其他语言不允许反向索引

切片默认边界

str[:n]包括了从字符串首到str[n-1]字符之间的所有字符，str[m:]包含了从str[m]到到字符串末尾的所有字符，str[:]表示整个str字符串

注：python不允许字符串中单个字符的索引越界，但是在切片中可以索引越界

字符串连接与重复

print("good"+"bye")  #goodbye

print("ha"*4) #hahahaha

注：字符串不能与一个数字进行连接操作

字符串函数和方法

• len(str) 返回str中的字符个数
• str.upper() 将str转换为大写字母
• str.lower() 将str转换为小写字母
• str.rstrip() 移除字符串末尾的换行符

注：字符串中的字符无法直接修改

数据类型转换

字符串转整形

a = '123'
b = int(a)  #强制转换

浮点数转整数

a = 5.11
b = int(a)  #最终b为5

整形转字符串

a = 11
b = str(a)  

注：其他转换以此类推

列表

• 列表(list)是python对象的一个有序序列，其中对象可以是任何类型，并不要求类型一致。
• 列表用中括号括起来，每个元素之间用逗号分隔。

  team =["hello",2019,"world",2019]
  nums = [1,2,3,4]
  words = ["hello","python"]

列表操作

以上述列表为例进行操作

• len() 列表中元素个数

  len(words)  #2

• max() 最大值(元素必须是相同类型)

  max(nums)   #4

• min() 最小值(元素必须是相同类型)

  min(nums)   #1

注：当max与min作用于包含字符串的列表时，字符串按字典排序进行比较

• sum() 求和(元素必须是数字)

  sum(nums)  #10

• count() 一个对象出现的次数

  team.count(2019)   #2

• index() 一个对象首次出现的索引位置

  team.index(2019)   #1

• reverse() 所有元素的逆序

  words.reverse()   #["python","hello"]

• append() 在列表末端插入对象

  words.append(2019)   #["hello","python",2019]

• extend() 在列表末端插入新列表的所有元素

  nums.extend([7,8])  #[1,2,3,4,7,8]

• del() 移除给定索引位置上的元素

  del team[-1]   #["hello",2019,"world"]

• remove() 移除一个对象的首次出现

  team.remove(2019)   #["hello","world",2019]

• insert(索引位置，元素) 在给定索引位置上插入新元素

  words.insert(1,2019) #["hello",2019,"python"]

• + 连接

  ["hello",2019]+["world",2020]   #等同于["hello",2019].extend("world",2020)

• * 列表重复

  [0]*3   #[0,0,0] 

注：在执行del/remove()方法后，列表中被删除元素后的其他元素会依次向左移动一个位置

切片

切片是由冒号语法表示的子列表
del list1[m:n] 移除list1中从索引m到n-1的所有元素

split和join方法

split

split将字符串变成其子串组成的列表
L = strVar.split(分隔符)

print("a,b,c".split(','))  #['a','b','c']

注：三种常用的单字符分隔符为’,’ / 换行符’\n’ / 空格，若没有指定分隔符，将使用空白分隔符(换行符、制表符和空格组成的任意字符串)作为分隔符

join

join是split方法的逆操作，将一个字符串列表变成一个由列表中所有元素用指定分隔符分割连接成的字符串
strVar = “,”.join(L)

line = ['a','b','c']
print(" ".join(line)) #["a b c"]
print(",".join(line))  #["a,b,c"]

元组对象

• 元组(tuple)与列表类似，是元素的有序列表。
• 元组与列表的主要区别在于元组不可以直接修改，即元组没有append,extend和insert方法
• 元组中的元素也不可以直接被修改或删除
• 列表中其他的函数和方法对元组同样适用
• 元组中的元素可以索引
• 元组可以切片、连接和重复
• 元组比列表更高效，因此应该在元素不会发生改变的情况下使用，它们执行得更快、内存占用更少，而且可以写“写保护”数据

注：单个元素组成的元组有一个末尾的逗号，如(0,)

元组定义

t = ('a','b','c')
或
t='a','b','c'

注：print函数总会显示由括号包围的元组

tuple函数

tuple函数可以将列表或字符串转化为元组。

tuple(['a','b'])  的值为 ('a','b')
tuple("python") 的值为('p','y','t','h','o','n')

嵌套列表

列表和元组中的元素也可以是列表或元组

regions = [("hello",2019),("world","python"),(2020,1999)]
print(regions[0][1]) #hello
print(regiions[2][0])  #2020
print(regions[0][1]+regions[2][1])  #2019+1999=4018

不可变对象和可变对象

• 对象是一个可以存储数据并有可以操纵数据的操作或方法实体。数值、字符串、列表和元组都是对象。
• 当一个变量使用赋值语句创建出来后，等号右边的值变成了内存中的一个对象
• 列表能够原地修改，但是数值、字符串和元组不可以。
• 能够原地修改的对象称为可变的，而不能原地修改的对象称为不可变的。

  L =[5,6]
  n = 2
  s = "python"
  t = ('a','b','c')
  L.append(7)
  n += 1
  s = s.upper()
  t = t[1:]

  在前四行代码执行后的内存分配情况
  

在全部代码执行后的内存分配情况

列表复制

list1 = ['a','b']
list2 = list1
list2[1] = 'c'
print(list1)   # ['a','c']

在第二行代码中，变量list2引用的是和list1一样的内存位置，对list2中一个元素的改变将对list1产生相同的变化
如果将第二行代码改成

list2 = list(list1)
或
list2 = list1[:]

注：list函数可以将元组或字符串转化为列表。例如：list((‘a’,’b’))的值为[‘a’,’b’] list(“python”)的值为[‘p’,’y’,’t’,’h’,’o’,’n’]

就不会出现上述情况，在这种情况下，list2指向了包含与list1一样的值，但list2是一个在不同内存位置上的对象，之后list1仍为[‘a’,’b’]