python基础_print('你好')print('我喜欢你')

Python

1. 运行速度缓慢， 需要将代码翻译成Cpu能理解的机器码
   2. 代码不能加密,

注意点：

1.print('hello world') print前面不能有空格

2.文件名必须以.py结尾

3.文件名只能是英文字母，数字和下划线的组合

print()函数可以接受多个字符串，用逗号，隔开

print('hello world','你好')

print()也可以打印整数和表达式（看成字符串的形式）

print(200)
print('100+200=',100+200)

input()获取输入的一些字符

name=input()
name => 'hello'

#注释，：结尾 缩进（4个空格），大小写敏感

 

python基础

数据类型

整数，浮点型，字符串，转义字符 \ (r' ' 表示 内部的‘ ’不进行转义)

输入多行的时候 提示符由>>> 变成 ...

输入完结束符 ''' ''' 和括号 ） 执行该语句并打印结果

>>> print('''hello
... world
... ''')
hello
world

多行字符串r ''' ''' 在前面加上r使用

布尔类型 True,False(注意大小写) and ,or,not 运算

空值 None（一个特殊的空值）不能理解为0；

变量 大小写英文，数字和—组合，不能用数字开头

=是赋值语句

同一变量可以反复赋值而且可以是不同类型的变量

动态语言

a='hello world'

 

静态语言 已经指定变量类型

int  a=1:

用全部大写的变量名表示常量

python两种除法

1. /除法结果是浮点数，即使整除，结果也是浮点数

2. // 地板除 两个整数的除法仍然是整数（永远是整数） 10//3 3

3. python的浮点数没有大小限制,但超过一定范围就直接表示为inf(无限大)

字符编码

ord()获取字符的整数表示

ord('A') => 65

chr()函数把编码转换为对应的字符

chr(66) =>'8'

python中bytes类型的数据用带b前缀的单引号或双引号

x=b'ABC'

unicode表示的str通过encode()可以编码为指导的bytes

'ABC'.encode('ascii') 
 #errors='ignore'忽略错误的字节
'ABC'.encode('ascii',errors='ignore')
#len()函数 获取str包含的多少个字符

一个中文字符占有三个字节，1个英文字符包含1个字节

%运算符 用来格式化字符串

>>> 'hello ,%s' %'world'
'hello ,world'

%%表示一个%

>>> 'name={0},age={1}'.format('小明',12)
'name=小明,age=12'

list []

数据类型（有序的集合）可以添加和删除其中的元素

>>> name=['张三','李四','王五']
>>> name
['张三', '李四', '王五']

len()函数获取list元素的个数

>>> len(name)
3

使用索引来访问每个位置的元素，索引从0开始

>>> name[0]
'张三'

如果想获取最后一个元素,除了索引 len(name)-1，name[-1]

其他依次类推-2 ，-3

>>> name[-1]
'王五'

list添加数据 append

>>> name.append('唐伯虎')
>>> name
['张三', '李四', '王五', '唐伯虎']

list插入数据到指定索引 insert()

>>> name.insert(2,'秋香')
>>> name
['张三', '李四', '秋香', '王五', '唐伯虎']

list删除末尾元素 pop

>>> name.pop()
'唐伯虎'
>>> name
['张三', '李四', '秋香', '王五']

删除指定位置的元素 使用索引 pop[i]

>>> name.pop(2)
'秋香'
>>> name
['张三', '李四', '王五']

list元素替换

>>> name
['张三', '李四', '王五']
>>> name[2]='love'
>>> name
['张三', '李四', 'love']

list里面的元素的数据类型可以是不同的

>>> list=['张三',23,True]
>>> list
['张三', 23, True]

也可以是另一个list

>>> list.append(name)
>>> list
['张三', 23, True, ['张三', '李四', 'love']]
#获取李四
>>> list[3][1]
'李四'

还可以是空的list

>>> L=[]
>>> len(L)
0

Tuple(元组) () =>一旦初始化就不能修改

tuple和list的区别

1.一旦初始化就不能被修改

2.没有append,insert()

tuple中的括号 既可以表示tuple也可以表示数学公式中的小括号

定义tuple

>>> t=(1,2,'张三')
>>> t
(1, 2, '张三')

定义空（）

>>> a=()
>>> a
()

注意点：

一个数

#这只是定义1这个数，不是指定tuple,为了区分 使用逗号隔开
>>> b=(1) 
>>> b
1
定义一个数的tuple
>>> c=(1,)
>>> c
(1,)

条件判断

name=['张三','李四','王五','love']
if len(name)<5:
  print(name)
else:
  print('没有数据')

if后面没有括号， 每个if后面必须有 ： 也可以使用elif

类型转换 int()

循环

for item in name:
print(item)

rang() 生成一个整数序列

rang(101)从0到开始小于101的倍数

可以通过list()转换成list集合

while

只有条件满足，就不断循环，条件不满足则退出

sum=0
n=10
while(n<11):
sum=sum+n
n=n-2
print(sum)

dict （不可变对象）

dict字典在其他语言叫map使用键值对存储，具有极快的查找速度

定义字典

>>> dicts={'name':'longletian','age':12,'sex':'男'}
>>> dicts
{'name': 'longletian', 'age': 12, 'sex': '男'}

通过in判断key是否存在

>>> 'name' in dicts
True

通过dict中的get() 如果key不存在返回 None 或者返回自己指定的value

>>> dicts.get('name')
'longletian'

字典，删除一个key,将value从value中删除 pop

>>> dicts.pop('name')
'longletian'
>>> dicts
{'age': 12, 'sex': '男'}

list和字典的区别

1.字典中特点 查找和插入速度极快，不会随着key的增加而变慢

2.需要占用大量的内存，内存浪费多

set

也是一组key的集合，但不存储value（需要引入list），由于key不能重复

重复元素在set中自动被过滤

>>> s=set(name)
>>> s
{'灌篮高手', '李四', 'love', '张三'}
#添加元素到set中 可以重复添加但不会有效果
>>> s.add(12)
>>> s
{'李四', 12, '灌篮高手', '张三', 'love'}

删除元素

>>> s.remove('李四')
>>> s
{12, '灌篮高手', '张三', 'love'}

两个set可以做数学上的交集，并集 & 和|

list排序

>>> a=['a','c','b']
>>> a.sort()
>>> a
['a', 'b', 'c']

字符串的替换

>>> str='abcd'
>>> str.replace('a','aa')
'aabcd'

不变对象 调用自身的任意方法，不会改变该对象自身的内容

只会创建新的对象并返回，

help(abs)

数据类型转换

int(),float(),str(),bool()

定义函数

使用def语句，依次写出函数名，括号，括号的参数和：

使用return返回

def add(a,b):
  return a+b

空函数

def nop():

返回多个值

def compout(x,y):
   z=x+y
   g=x-y
   return z,g
​

传入可变参数 ()

def add(*a):

关键字参数=>扩展函数功能（可以传入字典 dict）

def person(name,age,**info)

命名关键字参数

需要特殊分隔符*， *后面被称为命名关键字参数

如果已经有一个可变参数，后面的命名关键字参数就不需要了

递归函数

阶乘 fact(n)

使用递归函数，需要防止栈溢出，函数的调用通过栈结构是实现

每当进入一个函数调用，栈顶就增加一层栈帧，

函数返回，栈会减少一层

由于栈的大小不是无限，调用次数过多会导致栈溢出

解决栈溢出的方法是尾递归优化

切片 =>获取索引范围的操作

n=['zhansan','lisi','wangwu','zhangfei']
#获取2个元素
n[1:3]
#如果第一位是0
n[:3]
#获取最后一个元素  最后一个元素索引为-1
n[-1:]
#前6个每两个取一个
n[:6:2]
#每五个取一个
n[::5]
#什么也没有
n[:]

tuple

#tuple 切片还是tuple
name=(0,1,2,4,3,5,6,7)
name[:3]

字符串

'anbfbfb'[:3]
'abcdef'[::2]

迭代=>通过循环来遍历list,tuple

字典dict

默认迭代 key，要迭代值 dict.values() 同时迭代key和value dict.items()

判断一个对象是可迭代对象，可以通过collections模块的iterable类型判断

form  collections import Iterable
isinstace('abc',Iterable) 判断字符串是否可以迭代

python 内置的enumerate函数可以把一个list变成索引-元素对

for (i,value) in  enumerate(name)

列表生成器

list(range(1,11))

列表生成式

>>> [x*x for x in range(1,11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

生成器（generator） 可迭代对象

创建generator,把列表生成式的[]改成()

>>> names=(x*x for x in range(1,11))
>>> names
<generator object <genexpr> at 0x000001D8A87EC8B8>

打印generator的返回值

>>> next(names)
1

>>> g=(x*x for x in range(1,11))
>>> for n in g:
... print(n)

generator执行的顺序，

在每次调用next的时候执行 遇到yeild返回，

再次执行时从上次返回的yield语句继续执行

yield

总结

• 可以直接作用于for循环的对象统称为可迭代对象 Iterable

• 可以被next函数调用并不断返回的下一个值的对象成为迭代器 iterator

• 凡可以作用于for的对象都是iterable类型

• 凡可以作用域next对象都是iterator类型

• 集合数据类型如list,dict,str 等是iterable但不是iterator，

• 不过可以iter()函数获取的一个iterator对象

  python的for本质是不断调用next()函数

函数式编程（python不是纯函数编程）

• 允许将函数本身作为参数传入另一个函数，还允许返回一个函数

• 1. 函数本身也可以赋值给变量，即变量可以指向函数

  2. 变量可以指向函数本身

  3. 函数名也是变量

传入函数

• 既然变量可以指向函数，函数的参数能接收变量，

• 那么一个函数就可以接收另一个函数作为参数，这种函数叫高阶函数

Map和reduce函数

map接收两个参数，一个是函数，一个是iterable

map将传入的函数依次作用到序列的每一个元素，并把结果作为新的iterator返回

返回函数

返回函数=>方法里面的函数

返回值是方法里面执行方法的结果

 

 

 

 

 

 

python中四种输出方式

>>> name="张三"
>>> print(name,'我喜欢你')
张三 我喜欢你
>>> print(name+'我喜欢你')
张三我喜欢你
>>> print('%s我喜欢你'%name)
张三我喜欢你
>>> print(f{name}我喜欢你)
SyntaxError: invalid syntax
>>> print(f'{name}我喜欢你')
张三我喜欢你

字符串的复制 *

>>> name="zhangsan"
>>> name=name*2
>>> print(name)
zhangsanzhangsan

格式化字符串

• 字符串的拼接(加号)

  >>> print(name+'我喜欢你')
  zhangsanzhangsan我喜欢你
  

• 字符串不能与其他类型进行拼接

  >>> a='hello'
  >>> print(a+123)
  Traceback (most recent call last):
    File "<pyshell#12>", line 1, in <module>
      print(a+123)
  TypeError: can only concatenate str (not "int") to str
  

• 可以在字符串中指定占位符 参数需要 ‘%‘

  >>> print('%sworld'%a)
  helloworld
  #多个值传入，带括号
  >>> print('%s world %s'%(a,name))
  hello world zhangsanzhangsan
  # 对字符串进行截取 3-5位
  >>> print('%3.5s'%name)
  zhang
  # 小数点保留两位 %.2f
  >>> print('%.2f'%name)
  123.23
  

• 格式化字符串 f (参数需存在)

  >>> name='hello'
  >>> password='world'
  >>> print(f'{name}{password}')
  helloworld
  

布尔值

• True,Flase,None(空值 表示不存在) 注意大写

查看数据类型 type()函数

>>> print(type(name))
<class 'str'>

对象（object）

python一门面向对象的语言（对象为中心）

程序的运行，所有数据都保存在内存中

对象是内存中原来存储指定数据的一块区域

对象就是一个容器，专门用来存储数据

数值，字符串，布尔都是对象

对象结构：

• 每一个对象都要保存三种数据

• id (标识 （人的身份证号）)

  id用来标识对象的唯一性，每个对象都有唯一的id

  可以通过id()函数查看对象的id

  id 是由解析器生成的，在cpython，id就是对象的内存地址

  对象一旦创建，id就不能再更改

• type(类型)

  type用来标识当前对象所属的类型（int, str,float）

  类型决定对象有哪些功能

  通过type()函数来查看对象的类型

  python是一门强类型的语言，对象一旦创建类型不能再更改

• value(值)

  值就是对象存储的具体的数据

  对象分为两大类 可变对象，不可变对象

  可变对象的值可以改变

  不可变对象不可变

变量和对象

• 对象并没有直接存储到变量中

• 变量中存储的不是对象的值，而是对象的内存地址（id）

• 当我们需要使用变量时，实际上就是通过对象id查找对象（指向）

• 变量中保存的对象，只有在为变量重新赋值时才会改变

• 变量和变量之间是相互独立的，修改一个变量不会影响另一个值

  >>> a=123
  >>> print(id(a))
  140736859173328 #对象的内存地址
  >>> b=a
  >>> print(id(b))
  140736859173328
  

类型转换

• 可以将数据转换为int类型=>只会对数值起影响，不会改变对象的类型

• 规则

  布尔值 True=>1 ,Flase =>0

  浮点数 直接取整，

  字符串 合法字符串 直接转换为对于的数字

  如果不是合法的整数字符串，会报错

  对于其他不可转换为整数的对象，直接报错

• float()和int() 一致 将数据转换为浮点型

• str() 将对象转换为字符串类型

• bool() 任何对象都可以转换为布尔值

  对于所有表示空性的对象都会转换为Flase ，其他的转换为True

  0,Nono，' '

运算符

• 算法运算符

  • 加法运算符(+) 如果是两个字符串的加法运算，则会进行拼接

  • 减法运算符(-) 字符串不能进行减法运算

  • 乘法运算符(*) 如果是字符串和数字相乘，代表对字符串进行复制操作

  • 除法运算符(/) 运算时结果总会返回一个浮点类型，0不能作为除数

  • 整除（//） 只会保留计算后结果的整数位

  • 幂运算（**） 求一个数的幂运算

  • 取模（%）求一个数除以另一个数的余数

    >>> c=16
    >>> print(c**0.5)
  4.0
  

• 赋值运算符

• 关系运算符

  在python中，不支持整数与字符串的的对比

  支持字符串与字符串的对比，比较的是 unicode编码

  比较两个字符串的unicode编码时，是逐位对比 ab>c

  • is 比较两个对象是否是同一对象，比较的是对象的id

  • is not 同理相反

• 逻辑运算符

  • not 逻辑非

    对于符号右侧的值进行运算

    对布尔值，会对其进行取反操作，True =>Flase 同理

    对于非布尔值的，对将其变成转换为布尔值，在取反

  • and 逻辑与（找Flase）

    当我们对非布尔值进行与或运算时，python对将其当做布尔值运算，最终返回原值

    与运算规则，

    与运算是找Flase的，如果第一值是Flase，则不看第二个值

    如果第一个值是False,则直接返回第一个值，否则第二个值

    如果两个数都是True时，会返回最后一个值

  • or 逻辑或()

    与运算是找True的，如果第一值是True，则不看第二个值

    如果第一个值是True,则直接返回第一个值，否则第二个值

    如果两个数都是Flase时，会返回最后一个值

• 条件运算符（三元运算符）

  语句1 if 条件表达式 else 语句二

  条件运算符，会先对条件表达式进行求值判断

  如果结果为True，而执行语句一，并返回结果

  否则同理

  >>> max=a if a>b else b
  >>> print(max)
  144
  

• 运算符优先级

  运算符的优先级可以根据优先级的表格来查询

  在表格位置越靠下，优先级越高，

  优先级一样，则从左往右计算

 

• 条件判断语句（if语句）

  语法： if 条件表达式 ：

  代码块（注意缩进）

  执行流程：

  • if语句在执行时，会先对条件表达式进行求值判断

  如果为True,则执行if之后的语句

  同理

  代码块：

  • 代码块中保存一组代码，同一个代码块中的代码 要么都执行，要么都不执行

  • 代码块就是一种为代码分组的机制

  • 代码块以缩进开始，直到代码恢复到之前的缩进级别结束

  • 缩进： tab键， 空格（4个）