深度学习阶段一_Python基础01_02

02：Python语言概览、安装与运行

概览

优势：软件质量，开发效率，可移植性，库支持丰富，组件集成，面向对象，函数式编程，面向对象

劣势：运行效率（解释型语言）。

哪些公司在用：国外Google，Youtube，国内搜狐邮箱，知乎，扇贝背单词

能做什么：系统编程，GUI编程，网络脚本，Web（Django，Flask，），数据库，快速原型，数学及科学计算

集成开发环境：Windows-Pycharm   

Python运行-Pycharm

一：英文输入法,文件名后缀必须要改为.py

1.交互式提示符，IDLE,    Windows命令提示符，

2.脚本   编写脚本代码，保存为.py，在

windos下按住ctrl+c,进入系统提示符原本目录，python E:\Project\All_codes\Pycharm\DeepLearning\test1.py

运行打印出Hello

注：D:直接跳转文件夹，cd空格加文件名，进入下一文件

二：

将脚本语言运行结果放置在TXT文件里，用来放在文件中，方便测试。

注：python*.py > result.txt         将结果放在文本文件中

03：Python变量，数据类型，及存储

回顾：windows+R，输入cmd回车，进入windows命令提示符。

切换盘：              d：回车

进入某个盘：       cd  文件名 

返回上级目录：    cd..   

返回根目录：        cd\

不知道进入那个目录：   dir

python内部怎么运行：

概念层级

程序

模块

语句

表达式：创建，处理对象

变量

写变量与C#不一样，不需要申明变量类型

name = "TOM"
age = 22
score = 61.2

"""查看类型使用type"""
print(type(name))

"""查看值存在内存的哪里"""
id(name)

创建：变量在第一次赋值时就生成了

规则：

1.包含数字，字母，下划线 

2.只能以字母或下划线开头 

3.不能有空格

4.避免Python关键字或函数名

5.简短且有描述性

04：Python 常用数据类型概览

类型：变量无类型约束，类型取决于关联对象

使用：

垃圾回收机制：

Python自动释放未被引用的对象，

内部原理依据对象引用计数器统计的数值

共享引用：多个变量引用一个对象，

                  判断字面值是否相等：==

                  判断地址值是否相同：is

                  256以下整数，已被Python缓存

age = 20
score = 20
age is score
"""输出True"""

salary = 3100
lines = 3100
salary is lines
"""输出False"""

"""因为20是现成的，只能放256以下的，
用不用都是有的，放3100和预留的无关"""

import sys
sys.getrefcount(20)

对象类型

核心数据类型：

• 数字（int，float，Decimal，Fraction，，，）
• 字符串：str
• 列表：list
• 字典表：dict
• 元组：tuple
• 文件：file
• 集和：set
• 布尔：Boolean--True，False
• 空：None
• 程序单元：函数：function，模块，类：class

整型：a = 1.1 + 2.2    得到a的值是3.00000000003，不用管他，以后会有更加方便的方法，比如引入别人写好的库

字符串：

name = 'tom'
name[0]
name[2]
"""t，m"""

len(name)
"""3"""

name2 = name + "Jerry"
name2
"""tomJerry,表示字符串可以拼接"""

name*8
"""tomtomtomtomtomtomtomtom"""

05：数值和字符串

数值

l = [1, 2, 5, 13]
l = [1, 'abc' ,[2,3,4]]
"""列表类似数组，但是更强大，可实现嵌套"""

len(l)
"""3,输出列表长度"""

l[0]
"""1,输出第一位"""

l[1]
"""  'abc' ,输出第二位   """

字典：键值对

d = {'name':'Tom','age':20,'job':'dev'}
d['name']
"""   'Tom'   """

d.get('age')
"""20,获取值可以使用get函数，即使没有这个键也不会报错"""

tuple:

t = (1,2,3,4)
"""元组不能够修改，而列表可以通过索引修改"""

元组不能够修改，而列表可以通过索引修改

数据类型：

1. 数值--申明，赋值，使用，表达式

age = 20
print(age)
"""20"""

f = 3.14
f = 0.3
f = .3
print(f)
"""0.3,重新赋值，前面的值会被废弃掉,垃圾回收"""

显示：

'{0}'.format(20)
"""  '20' """

'3 + 2 = {0}'.format(5)
'3 + 2 = 5'
"""把5这个值传递到{0}来"""

f = 3.3333
'f={0:.2f}'.format(f)
""" 'f=3.33'      表示将f传入到{0}中，.2代表精确到小数点后两位，f代表浮点型"""

字符串：

d = {'name': 'Tom', 'age': '20', 'job': 'dev'}
'姓名：{0}，年龄：{1}'.format(d.get('name'), d.get('age'))
print('姓名：{0}，年龄：{1}'.format(d.get('name'), d.get('age')))
"""  姓名：Tom，年龄：20  """

比较：

       返回布尔型结果：True，False-->, <, >=, <=, ==, !=

除法：/   //   

10 / 4
"""  2.5 除法 """
10 // 4
"""  2  除法取整"""
10 // 4.0
"""  2.0  除法，按精度高的操作"""

取整:

          math.floor()往左

          math.trunc()往0

          round()四舍五入

import math
math.floor(3.4)
math.floor(-3.4)
"""3  4   都是往左边移"""

math.trunc(-3.14)
math.trunc(3.94)
"""-3  3  往0的中间移动"""

round(3.14)
round(3.94)
"""3  4  四舍五入"""

  整型：无限精度，仅受限于内存与计算机配置，

  二进制，八进制，十六进制

               字面值：0o  8进制，0x  16进制，0b  2进制

               转换：oct(),  hex(),  bin()

0x9
"""9"""

oct(64)
"""0o100"""

hex(64)
"""0x40"""

bin(64)
"""0b1000000"""

Decimal

import decimal
decimal.Decimal(3.14)
decimal.Decimal('1.1') + decimal.Decimal('2.2')

"""Decimal('3.3')"""

布尔型

3 > 2
""" True"""

True == 1
False == 0
"""True,False   表示True就是等于0，False就是等于0"""

字符串：

                申明：三种      ' '     " "      """  """

                转义符：   \      \*    \\*    \n(换行)    \b(退格)   \t   ....

                忽略转义符：r' .....'

字符串的基本操作：

name = 'tom'
len(name)
"""3"""

'abc' + 'xyz'
"""abcxyz"""

'OK'*5
"OKOKOKOKOK"

print('-'*30)
'------------------------'

s = hello
for c in s:
    print(c)
"""
h
e
l
l
o
"""

s[0]
"""h"""

for c in s:
    print(c,end=' ')
"""h e l l o"""

s = 'abcdefghijklmnop'

s[0:4]
"""abcd"""

s[-1]
"""p"""

s[len(s)-1]
"""p"""

s[-1]
"""p"""

s[:]
"""abcdefghijklnmop还需要多熟悉"""

字符串不支持原位改变，可以使用替换和重新赋值。

h = 'hello'
h.replace('e','a')
"""hallo"""

h = h.replace('e','a')
"""hallo"""

这两种不一样，前者还是hello，而后者通过重新赋值就改变回来了

s = 'codeclassroom.cn'
l = list(s)
print(l)

s = ''.join(l)
print(s)

['c', 'o', 'd', 'e', 'c', 'l', 'a', 's', 's', 'r', 'o', 'o', 'm', '.', 'c', 'n']
codeclassroom.cn
"""通过join空字符串来连接,字符串的一个实例方法"""

url = 'codeclassroom.com,uke.cc,youpingketang.com'
l = url.split(',')
print(l)
""" ['codeclassroom.com', 'uke.cc', 'youpingketang.com'] """

基本操作：

                  .replace('a','b')替换

                  .split()切割，括号里面放以什么切割

                  .startswith()以什么开头

                  .endswith()以什么结尾

                  .find()寻找是否有没有括号里的东西

url = 'uke.cc'
url.startswith('http://')
"""False"""

url.startswith('u')
"""True"""

url.find('.')
"""3         寻找是否存在"""

a,b = b,a
'{0} => {1}'.format(a,b)
"""2 =>1"""

'{} => {}'.format(a,b)
"""2 =>1          没有索引也会照着排"""

'{name} => {salary}'.format(name='Tom',salary='9000')
"""  Tom =>9000      怕位置串了，这个明显些"""

  列表list

           任意对象的有序集合，通过索引下标访问元素，可变长度，属于可变序列

常用操作：

               .append()添加一个

               .extend()扩展列表

               .sort()排序

               .reverse()翻转

               .index()检索某一项

               .count()计数某一项

               .copy()复制哪个列表

注意：引用类型，支持原位改变

              拷贝副本：   .copy()

len([1,2,3])
"""3"""

[1,2,3] + [4,5,6]
"""[1,2,3,4,5,6]"""

l = list('youpingketang')
'k' in l
"""True          遍历"""

for c in l:
    print(c)
"""
y
o
u
.
.
.
"""

for c in l:
    print(c, end='') 
"""youpingketang"""

l = [1,2,3,6,9]
res = []
for i in l:
    res.append(i**2)
"""[1, 2, 9, 36, 81]     将里面每个都变成平方"""

l1 = [i**2 for i in l]    列表推导，方便多了,与上面一个意思

[c*3 for c in 'code']
""" ['ccc','ooo','DDD','EEE']  """

l = [1,2,3]
l[1:2] = [4,5]
"""[1,4,5,3]"""

['uke.cc'] *3
"""['uke.cc','uke.cc','uke.cc']"""面试经常会考，不是产生三个列表

l.append(7)
"""[1,4,5,3,7]"""只追加一个
l.extend([9,8,5])
"""[1,4,5,3,7,9,8,5]"""扩展列表

l.sort()
"""[1,3,4,5,5,7,8,9]"""

l.reverse()
"""[9,8,7,6,5,5,4,3,1]"""

l.pop()
1
"""[9,8,7,6,5,5,4,3]""" 1就没有了,弹出

del(l[0])
"""[8,7,5,5,4]          删除，全局的"""

l.index(7)
"""1           寻找7的下标"""

l.count(5)
"""2           看有多少个5"""

"""复制列表而不改变原来列表,对l1没有影响"""
l3 = l1[:]

l4 = l1.copy()