Python入门

[yingwinwin]

1. 安装

• Python官网下载安装包 Download Windows x86-64 executable installerwindows选择exe安装包。安装时需要勾选环境变量。
• PyCharm官网下载社区版即可。

2. 初识python

• 命令行模式：可以直接在命令行中写python hello.py运行文件
• 交互模式：直接进行运算和结果的输出，但是不能保存，输入python就可以进入。exit()就会离开交互模式
• print('输出')
• input(’输入‘)

  name = input('please enter your name : ')
  print('hello, ' + name + '!')

  3. Python基础

  1.数据类型

• 整数
• 浮点数
• 字符串

  # r’‘的使用
  print(r'\\\t\\') 
  # \\\t\\    输出这个

  # 换行符的使用（在py文件中）
  print('''line1
  line2
  line3''') 
  # 换行符的使用（在交互模式中）· · · 是系统生成的不是手打上去的。
  >>>print('''line1
  · · · line2
  · · · line3''')

• 布尔值 True False前端是小写true false and or not相对于前端的&& || !
• 空值 None

  2.变量和常量

  a = 1 #a是变量
  PI = 3.1415925  #python中常量一般用大写

• 地板除

  # 正常除法
  10/3
  3.333333333
  #地板除
  10//3
  3

3. 字符串与编码

• ASCII码 127个字符
• GB2312 中国
• Unicode 所有语言
• UTF-8 比unicode更节省空间

  3.1 Python的字符串

• 方法

转字符 ord()函数获取字符的整数表示 chr()函数把编码 转换为对应的字符 转bytes Python 对 bytes类型的数据用带 b x = b'ABC

#`encode()`把字符串生成指定`bytes`
'中'.encode('utf-8')
#b'\xe4\xb8\xad'

# decode()方法把 bytes 变为 str
b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8') 
'中文'

如果 bytes中只有一小部分无效的字节，可以传入 errors='ignore'忽略错误的字节

b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore') 
'中'

计算字符串的长度len()

len(b'abc')  # 3

让python是utf-8读取在文件开头

#!/usr/bin/env python3
 # -*- coding: utf-8 -*

3.2格式化

'hello %s' %  'world'
# 'hello world'
 'Hi, %s, you have $%d' % ('Monica', 10000)
# 'Hi, Monica, you have $10000'

%是用来格式化字符串的，有几个%，后面就跟几个变量，一个变量时不用加括号

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

4. list 和 tuple

4.1 list 有序列表

classmates = [ 'Michael', 'Bob', 'Tracy']
# 1. 获取列表的长度
len(classmates)   # 3

# 2. 访问列表的内容
classmates[0]  
#  'Michael'   注意与前端不同，python超出索引值会报错。
#  也可用负数，classmates[-1]获取最后一个元素， len(classmates) - 1也是获取最后一个元素

# 3. 插入元素到结尾 - append
classmates.append('Adam')  #会改变原来的列表
# ['Michael', 'Bob', 'Tracy', 'Adam']

# 4. 插入元素到指定位置 - insert
classmates.insert(1, 'Jack') 
# ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

# 5. 删除末尾元素- pop
classmates.pop() # 返回删除的这一项‘Adam’ ， 也会改变原来的数组
# ['Michael', 'Jack', 'Bob', 'Tracy']

# 6. 删除指定位置的元素 - pop(i)   i是下标值
classmates.pop(1)  # 同样返回删除的一项，对原数组更改
# ['Michael', 'Bob', 'Tracy'] 

4.2 tuple 元组

# 元组中的元素不可改变，只能取值。
classmates = ('Michael', 'Bob', 'Tracy')

# 需要注意的点
t = (1, 2)   # 输出(1, 2)
t = (1, )  # 输出( 1, )  所以这里需要加一个逗号，来区分整形1
t = (1)   #输出 1 是一个整数，不是元组。

# 在这种情况下tuple可变，在内存中改变list的值。
t = ('a', 'b', ['A', 'B']) 
t[2][0] = 'X'
t[2][1] = 'Y' 
# ('a', 'b', ['X', 'Y']) 

5. 条件判断语句(多选一)

a = input('please input your age: ')
# 用户输入的input值是一个，字符串不可以用来比较，所以需要用int()方法来吧str格式变成num
age = int(a)
# 如果age>=18为True，就执行下面的语句
if age >= 18:
    print('your age is', age)
    print('adult')
#elif和前端的 else if相同
elif age >= 6:
    print('your age is', age)
    print('teenager')
else:
    print('kid')

6.循环

6.1 三种循环方式

# list列表的遍历
names = ['Michael', 'Bob', 'Tracy']
#前面是变量里面的元素,后面是循环的变量
for item in names:
    print(item)
# 输出
# Michael
# Bob
# Tracy

# 顺序数字的遍历 range()
arr = list(range(5))
print(arr) # [0, 1, 2, 3, 4]

sum = 0
# range(101)是 0 - 100
for x in range(101):
    sum = sum + x
print(sum)  #5050

# while循环
sum = 0
n = 100
while n > 0:  #注意:冒号
    sum = sum + n  #注意缩进
    n = n - 1
print(sum)  #5050

6.2 break continue 关键字（大多数循环并不需要用到 break 和 continue 语句

#break关键字
n = 1
while n <= 100:
    if n > 10: #当n大于10的时候执行break,将停止循环
        break
    print(n) #在循环里面,会输入1-10
    n = n + 1
print('end')

# continue 关键字
n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0:  #当n满足条件是偶数时,执行continue,停止当次循环
        continue
    print(n)  # 1 3 5 7 9

7. 使用dict 和 set

• dict就是前端的对象{}

  
  d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
  # 插入
  d['Adam'] = 67
  #查找
  print(d['Adam'])  # 67
  #删除Key
  print(d.pop('Bob')) #75 (返回被删除的value)

如果查找的key不存在,就会报错

两个方式检验是否存在

1.用 in 方法, 返回值为布尔值

print('Thomas' in d) # False

2. get()方法 , 不存在返回None

print(d.get('Thomas')) # None

注意: dict的 key 是不可变对象, 可以用字符串和整数做key不可用list做key

- set 和 ES6中的set基本一致(没有value，没有重复的key
```python
# 传入set的是list,输出是set内部有什么内容.重复的内容会被省略
s = set([1,1,2,3])
print(s)  # {1, 2, 3}

# 添加
s.add(4)
print(s) # {1, 2, 3, 4}

# 删除
s.remove(2)
print(s) # {1, 3, 4}

# set的交集 并集
s1 = set([1,2,3])
s2 = set([2,3,4])
print(s1 & s2) # {2, 3}
print(s1 | s2) # {1, 2, 3, 4}

7. 函数

7.1内置函数

• 官方文档
• 在交互命令行中help(abs)

print(abs(-10))   # 10 输出绝对值
print(max(1,3))   # 3 输出最大值
print(int('123')) # 123 将字符串数字转为数字123
print(float('12.34')) #12.34 将浮点数字符串转为数字12.34
print(str(1.23)) # '1.23' 将数字转字符串
print(bool('')) #False 将元素转布尔值

7.2定义函数

• return 函数的返回值,默认为None

  # 定义一个返回绝对值的函数
  def my_abs(x):
  if(x >= 0):
      return x
  else:
      return -x
  print(my_abs(-99))  # 99

• 空函数 pass(还没想好怎么写,pass可以用来占位,不会报错)

  def my_abs(x):
  pass
  print(my_abs(1))  #None

• 参数检查

  def my_abs(x):
  # 用isinstance检查
  if not isinstance(x, (int, float)):
      raise TypeError('bad operand type')
  if(x >= 0):
      return x
  else:
      return -x
  print(my_abs('1'))  # raise TypeError('bad operand type')

• 函数多个返回值

  import math  #引入math包
  def move(x, y , step, angle = 0):
  nx = x + step * math.cos(angle)
  ny = y - step * math.sin(angle)
  return nx, ny
  print(move(100, 100, 60, math.pi / 6))  #(151.96152422706632, 70.0) 返回是一个tuple

  7.3函数的参数

• 位置参数

  def power(x, n):
  s = 1
  while n > 0:
      n = n - 1
      s = s * x
  return s
  print(power(5, 3))  #125 按顺序传入参数

• 默认参数

  def power(x, n = 2):
  s = 1
  while n > 0:
      n = n - 1
      s = s * x
  return s
  print(power(5))  # 25

  注意 :

  1. 默认参数要放在位置参数后面
  2. 把变化大的参数放前面，变化小的参数放后面
  3. 默认参数必须指向不变的对象,不可用list

• 可变参数 *

  def calc(*number):
  sum = 0
  for n in number:
      sum = sum + n * n
  return sum
  # 可以定义一个变量
  number = [1,2,3,4]
  # 在这里直接用*变量传入,也可传入0个,直接传入用逗号隔开也可
  print(calc(*number)) # 30

• 关键字参数 **表示,变成dict

  def person(name, age , **kw):
  print('name:',name, 'age:', age, 'other:', kw )
  person('ying', 24 , city='Harbin')   # name: ying age: 24 other: {'city': 'Harbin'}

• 命名关键字参数

  
  # 1. 限制关键字参数的名字,*号后面即为必传关键字
  def person(name, age , *, city, job):
  print(name, age, city, job)
  person('jack',24, city='beijing',job='engineers')
  # jack 24 beijing engineers

2. 如果有可变参数存在,就不用在加*了,但是也必须要传入命名参数

def person(name, age , *args, city, job): print(name, age,args, city, job) person('jack',24, city='beijing',job='engineers')

jack 24 () beijing engineers

3. 可用默认参数

def person(name, age , *, city='beijing', job): print(name, age, city, job) person('jack', 24, job = 'engineer')

jack 24 beijing engineers

- 参数组合
1. 参数可组合使用
2. 组合的顺序 : 必选参数、 默认参数、可变参数、命名关键字参数和关键字参数
3. 虽然可以组合多达 5 种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差

**7.4 递归函数**
```python
def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)
print(fact(5))   # 120

递归次数过多,会导致栈溢出,用尾递归优化解决

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)
print(fact(5))

[yingwinwin]

4. 高级特性

1. 切片

1.1 基本用法

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'] 
# 取出前三个变量，不用循环  下标为0，1，2的元素
print(L[:3])   # ['Michael', 'Sarah', 'Tracy']

# 取出从指定位置的元素
print(L[1:3])  # ['Sarah', 'Tracy']

# 支持负数
print(L[-2:])  #['Bob', 'Jack']
print(L[-2:-1])  #['Bob']

1.2 高级用法

L = list(range(100)) # 0-99

# 取出前十个数
print(L[:10]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 后十个数
print(L[-10:]) # [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

# 11 - 20 个数
print(L[10:20]) # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

# 前10个数,每两个取一个
print(L[:10:2]) # [0, 2, 4, 6, 8]

# 所有数每5个取一个
print(L[::5]) # [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

# 取出所有数
print(L[:])

1.3 tuple和str的切片

# 取出tuple的前三项
print((1,2,3,4,5)[:3])  # (1, 2, 3)

# 取出字符串的前三项
print('ABCDEFG'[:3])  # ABC  

2. 迭代

2.1 基本用法

# 循环 dict (默认循环key)
d = {'a': 1, 'b': 2, 'c': 3}
for key in d:
    print(key)
# a b c    

# 循环 dict的 value
for value in d.values():
    print(value)
# 1 2 3

# 同时循环 dict 的  key 和 value
for k, v in d.items():
    print(k, v)
# a 1
# b 2
# c 3

# 迭代字符串
for ch in 'abc':
    print(ch)
# a b c4

# 实现下标循环 enumerate函数
for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)
# 0 A
# 1 B
# 2 C

# 同时引用两个变量
for x, y in [(1,1), (2, 4), (3, 9)]:
    print(x, y)
# 1 1
# 2 4
# 3 9

2.2 检测是否可迭代

# 判断是否为可迭代对象
from collections.abc import Iterable
print(isinstance('abc', Iterable)) # str 是否可以迭代
# True
print(isinstance([1,2,3], Iterable)) # list 是否可以迭代
# True
print(isinstance(123, Iterable)) # 整数是否可迭
# False

3. 列表生成式(python用于生成list

3.1 单变量

list(range(1,11))  # 生成1-10

print([x * x for x in range(1, 11)])  #生成1*1 2*2···10*10
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

print([x * x for x in range(1, 11) if x % 2 == 0])  # 偶数
# [4, 16, 36, 64, 100]

print([m + n for m in 'ABC' for n in 'XYZ']) #组合
# ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

import os # 导入os模块,模块的概念后面讲到
print([d for d in os.listdir('.')]) #os.listdir可以列出文件和目录

3.2 多变量操作

d = {'x': 'A', 'y': 'B', 'z': 'C' }
print([k + '=' + v for k, v in d.items()])
# ['x=A', 'y=B', 'z=C']

L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in L])   # 变小写
# ['hello', 'world', 'ibm', 'apple'] 

4. 生成器

4.1 简单的生成器

g = (x * x for x in range(10))
print(next(g))   # 1
print(next(g))   # 4
print(next(g))   # 9

4.2 生成器写斐波拉契数列

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

# 迭代生成器
for n in fib(6):
    print(n)

# 拿到生成器的return的返回值
g = fib(6)

while True:
    try:
        x = next(g)
        print('g', x)
    except StopIteration as e:
        print(e.value)
        break
print(g)